home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / public / SciAn / src / ScianDraw.c < prev    next >
C/C++ Source or Header  |  1994-08-01  |  63KB  |  2,714 lines
  1. /*ScianDraw.c
  2.   Drawing routines for various types of objects
  3.   Eric Pepke
  4.   March 28, 1990
  5. */
  6.  
  7. /* JEL added PostScript drawing 4/2/92 */
  8.  
  9. #include "Scian.h"
  10. #include "ScianTypes.h"
  11. #include "ScianArrays.h"
  12. #include "ScianLists.h"
  13. #include "ScianIDs.h"
  14. #include "ScianWindows.h"
  15. #include "ScianDraw.h"
  16. #include "ScianObjWindows.h"
  17. #include "ScianColors.h"
  18. #include "ScianPictures.h"
  19. #include "ScianStyle.h"
  20. #include "ScianFontSystem.h"
  21.  
  22. extern short LinToGamma[];
  23.  
  24. DrawingState drawingStates[NDRAWINGSTATES];    /*Stack of drawing states*/
  25. int curDrawingStateIndex = 0;            /*Current drawing state*/
  26.  
  27. Bool drawMouse = false;                /*True iff draw on next mouse*/
  28. extern int curMouse;                /*Current mouse button*/
  29.  
  30. int drawingMode = DRAW_SCREEN;            /*Drawing to the screen*/
  31. FILE *drawFile = 0;                /*File in which to draw*/
  32.  
  33. int imageSubSample = 0;                /*Subsampling offset for image*/
  34.  
  35. Bool fullScreen = false;            /*True iff drawing to full screen*/
  36.  
  37. Matrix Identity = {{1.0, 0.0, 0.0, 0.0},
  38.            {0.0, 1.0, 0.0, 0.0},
  39.            {0.0, 0.0, 1.0, 0.0},
  40.            {0.0, 0.0, 0.0, 1.0}};
  41.  
  42. /* globals used for PostScript drawing */
  43. FILE *psFile;        /* pointer to temp file */
  44. int iconsUsed[32];    /* maximum number of *different* icons in EPS file is 32 */
  45. int numIconsUsed;    /* number used so far = next index to use */
  46. Bool evenOnly = false;
  47. Bool oddOnly = false;
  48.  
  49. #ifdef PROTO
  50. void BeginTranslucent(void)
  51. #else
  52. void BeginTranslucent()
  53. #endif
  54. /*Begins translucent drawing*/
  55. {
  56. #ifdef GRAPHICS
  57.     if (evenOnly)
  58.     {
  59.     setpattern(EVENGREYPAT);
  60.     }
  61.     else if (oddOnly)
  62.     {
  63.     setpattern(ODDGREYPAT);
  64.     }
  65.     else
  66.     {
  67.     setpattern(GREYPAT);
  68.     }
  69. #endif
  70. }
  71.  
  72. #ifdef PROTO
  73. void EndTranslucent(void)
  74. #else
  75. void BeginTranslucent()
  76. #endif
  77. /*Begins translucent drawing*/
  78. {
  79. #ifdef GRAPHICS
  80.     if (evenOnly)
  81.     {
  82.     setpattern(EVENPAT);
  83.     }
  84.     else if (oddOnly)
  85.     {
  86.     setpattern(ODDPAT);
  87.     }
  88.     else
  89.     {
  90.     setpattern(SOLIDPAT);
  91.     }
  92. #endif
  93. }
  94.  
  95. #ifdef PROTO
  96. void BeginEvenOnly(void)
  97. #else
  98. void BeginEvenOnly()
  99. #endif
  100. /*Begins drawing on only even lines*/
  101. {
  102.     evenOnly = true;
  103. #ifdef GRAPHICS
  104.     setpattern(EVENPAT);
  105. #endif
  106. }
  107.  
  108. #ifdef PROTO
  109. void EndEvenOnly(void)
  110. #else
  111. void EndEvenOnly()
  112. #endif
  113. /*Ends drawing on only even lines*/
  114. {
  115.     evenOnly = false;
  116. #ifdef GRAPHICS
  117.     setpattern(SOLIDPAT);
  118. #endif
  119. }
  120.  
  121. #ifdef PROTO
  122. void BeginOddOnly(void)
  123. #else
  124. void BeginOddOnly()
  125. #endif
  126. /*Begins drawing on only odd lines*/
  127. {
  128.     oddOnly = true;
  129. #ifdef GRAPHICS
  130.     setpattern(ODDPAT);
  131. #endif
  132. }
  133.  
  134. #ifdef PROTO
  135. void EndOddOnly(void)
  136. #else
  137. void EndEvenOnly()
  138. #endif
  139. /*Ends drawing on only odd lines*/
  140. {
  141.     oddOnly = false;
  142. #ifdef GRAPHICS
  143.     setpattern(SOLIDPAT);
  144. #endif
  145. }
  146.  
  147. #if 0
  148. void EchoDraw(s)
  149. char *s;
  150. {
  151.     int k;
  152.     for (k = 0; k < curDrawingStateIndex; ++k) printf("  ");
  153.     printf("%s\n", s);
  154. }
  155. #else
  156. #define EchoDraw(s)
  157. #endif
  158.  
  159. #ifdef PROTO
  160. void PushTransformation(void)
  161. #else
  162. void PushTransformation()
  163. #endif
  164. /*Pushes the transformation*/
  165. {
  166. #ifdef GRAPHICS
  167.     pushmatrix();
  168. #endif
  169. }
  170.  
  171. #ifdef PROTO
  172. void PopTransformation(void)
  173. #else
  174. void PopTransformation()
  175. #endif
  176. /*Pushes the transformation*/
  177. {
  178. #ifdef GRAPHICS
  179.     popmatrix();
  180. #endif
  181. }
  182.  
  183. void PushDrawingState()
  184. /*Pushes the drawing state, producing a copy of the top drawing state*/
  185. {
  186.     int k;
  187.  
  188.     ++curDrawingStateIndex;
  189.     if (curDrawingStateIndex >= NDRAWINGSTATES)
  190.     {
  191.     fprintf(stderr, "SciAn: Panic, drawing state overflow\n");
  192.     exit(-1);
  193.     }
  194.  
  195.     CURSTATE . window = LASTSTATE . window;
  196.     CURSTATE . initialWindow = false;
  197.     for (k = 0; k < 4; ++k)
  198.     {
  199.     CURSTATE . screenMask[k] = LASTSTATE . screenMask[k];
  200.     CURSTATE . viewport[k] = LASTSTATE . viewport[k];
  201.     }
  202.     for (k = 0; k < 2; ++k)
  203.     {
  204.     CURSTATE . origin[k] = LASTSTATE . origin[k];
  205.     CURSTATE . translation[k] = LASTSTATE . translation[k];
  206.     }
  207. }
  208.  
  209. void PopDrawingState()
  210. /*Pops the drawing state and sets everything back to what it was.
  211.   As a side-effect, may set the window*/
  212. {
  213.     Bool setViewport = false;    /*True iff the viewport needs to be set*/
  214.  
  215.     --curDrawingStateIndex;
  216.  
  217.     if (curDrawingStateIndex < 0)
  218.     {
  219.     fprintf(stderr, "SciAn: Panic, drawing state underflow\n");
  220.     exit(-1);
  221.     }
  222.  
  223.     if (!(CURSTATE . window))
  224.     {
  225.     /*No window, do nothing*/
  226.     return;
  227.     }
  228.  
  229.     if (NEXTSTATE . initialWindow)
  230.     {
  231.     /*New window!  Need to set everything*/
  232.     SelWindow(CURSTATE . window);
  233.  
  234. #ifdef GRAPHICS
  235.     shademodel(FLAT);
  236.     concave(TRUE);
  237.     backface(FALSE);
  238.     lmcolor(LMC_COLOR);
  239.     {
  240.         float n[3];
  241.         n[0] = 0.0;
  242.         n[1] = 0.0;
  243.         n[2] = 1.0;
  244.         N3F(n);
  245.     }
  246. #endif
  247.     setViewport = true;
  248.     }
  249.  
  250.     if (setViewport ||
  251.     (CURSTATE . viewport[0] != NEXTSTATE . viewport[0]) ||
  252.     (CURSTATE . viewport[1] != NEXTSTATE . viewport[1]) ||
  253.     (CURSTATE . viewport[2] != NEXTSTATE . viewport[2]) ||
  254.     (CURSTATE . viewport[3] != NEXTSTATE . viewport[3]))
  255.     {
  256.     /*New viewport.  Need to set viewport*/
  257.     setViewport = true;
  258.  
  259. #ifdef GRAPHICS
  260.     if (drawingMode == DRAW_SCREEN)
  261.     {
  262.         /*Set the viewport in pixel-centered coordinates*/
  263.         viewport((Screencoord) CURSTATE . viewport[0],
  264.          (Screencoord) CURSTATE . viewport[1] - 1, 
  265.          (Screencoord) CURSTATE . viewport[2],
  266.          (Screencoord) CURSTATE . viewport[3] - 1);
  267.  
  268.         /*Set up an orthographic perspective setup to map to this viewport*/
  269.         MakeOrthoXform();
  270.     }
  271.     else if (drawingMode == DRAW_POSTSCRIPT && psFile)
  272.     {
  273.         fprintf(psFile, "%%new viewport\n%d %d translate\n",
  274.         (int) CURSTATE . translation[0], (int) CURSTATE . translation[1]);
  275.  
  276.     }
  277. #endif
  278.     }
  279.  
  280.     if (setViewport || 
  281.     (CURSTATE . screenMask[0] != NEXTSTATE . screenMask[0]) ||
  282.     (CURSTATE . screenMask[1] != NEXTSTATE . screenMask[1]) ||
  283.     (CURSTATE . screenMask[2] != NEXTSTATE . screenMask[2]) ||
  284.     (CURSTATE . screenMask[3] != NEXTSTATE . screenMask[3]))
  285.     {
  286.     /*New screen mask.  Need to set it*/
  287.  
  288.     if (drawingMode == DRAW_SCREEN)
  289.     {
  290. #ifdef GRAPHICS
  291.         scrmask((Screencoord) CURSTATE . screenMask[0],
  292.         (Screencoord) CURSTATE . screenMask[1] - 1, 
  293.         (Screencoord) CURSTATE . screenMask[2],
  294.         (Screencoord) CURSTATE . screenMask[3] - 1);
  295. #endif
  296.     }
  297.     else if (drawingMode == DRAW_POSTSCRIPT && psFile)
  298.     {
  299.         int sl, sr, sb, st;
  300.         sl = CURSTATE . screenMask[0];
  301.         sr = CURSTATE . screenMask[1];
  302.         sb = CURSTATE . screenMask[2];
  303.         st = CURSTATE . screenMask[3];
  304.  
  305.         fprintf(psFile,
  306. "resetclip newpath %d %d moveto %d %d lineto %d %d lineto %d %d lineto closepath clip newpath\n",
  307.         sl, st, sr, st, sr, sb, sl, sb);
  308.     }
  309.     }
  310.  
  311.     if ((setViewport == false) &&
  312.     (CURSTATE . translation[0] != NEXTSTATE . translation[0] ||
  313.      CURSTATE . translation[1] != NEXTSTATE . translation[1]))
  314.     {
  315.     if (drawingMode == DRAW_SCREEN)
  316.     {
  317. #ifdef GRAPHICS
  318.         /*Translate back, but only if only the translation is different*/
  319.         translate(    (Coord) (CURSTATE . translation[0] - NEXTSTATE . translation[0]),
  320.             (Coord) (CURSTATE . translation[1] - NEXTSTATE . translation[1]),
  321.             (Coord) 0.0);
  322. #endif
  323.     }
  324.     else if (drawingMode == DRAW_POSTSCRIPT && psFile)
  325.     {
  326.             fprintf(psFile, "%d %d translate\n",
  327.             (int) (CURSTATE . translation[0] - NEXTSTATE . translation[0]),
  328.         (int) (CURSTATE . translation[1] - NEXTSTATE . translation[1]));
  329.     }
  330.     }
  331. }
  332.  
  333. #ifdef PROTO
  334. void SetDrawingWindow(WinInfoPtr window)
  335. #else
  336. void SetDrawingWindow(window)
  337. WinInfoPtr window;
  338. #endif
  339. /*Sets to draw into a new window.  Side effect--selects the window*/
  340. {
  341.     int k;
  342.     int l, r, b, t, ox, oy;
  343.  
  344.     EchoDraw("SetDrawingWindow");
  345.  
  346.     /*Save the current window, etc.*/
  347.     PushDrawingState();
  348.  
  349.     /*Select this window and use it*/
  350.     SelWindow(window);
  351. #ifdef GRAPHICS
  352.     shademodel(FLAT);
  353.     concave(TRUE);
  354.     backface(FALSE);
  355.     lmcolor(LMC_COLOR);
  356.     {
  357.         float n[3];
  358.         n[0] = 0.0;
  359.         n[1] = 0.0;
  360.         n[2] = 1.0;
  361.         N3F(n);
  362.     }
  363. #endif
  364.  
  365.     CURSTATE . window = window;
  366.     CURSTATE . initialWindow = true;
  367.  
  368.     /*Zero translation*/
  369.     for (k = 0; k < 2; ++k)
  370.     {
  371.     CURSTATE . translation[k] = 0;
  372.     }
  373.  
  374.     /*Get the bounds of the window, in Mac style coordinates*/
  375.     GetWindowBounds(&l, &r, &b, &t);
  376.  
  377.     /*Save the bounds as the viewport and mask*/
  378.     CURSTATE . screenMask[0] = CURSTATE . viewport[0] = l;
  379.     CURSTATE . screenMask[1] = CURSTATE . viewport[1] = r;
  380.     CURSTATE . screenMask[2] = CURSTATE . viewport[2] = b;
  381.     CURSTATE . screenMask[3] = CURSTATE . viewport[3] = t;
  382.  
  383.     /*Get the origin of the window*/
  384.     GetWindowOrigin(&ox, &oy);
  385.     CURSTATE . origin[0] = ox;
  386.     CURSTATE . origin[1] = oy;
  387.     
  388. #ifdef GRAPHICS
  389.     if (drawingMode == DRAW_SCREEN)
  390.     {
  391.     /*Set the viewport in pixel-centered coordinates*/
  392.     viewport((Screencoord) l, (Screencoord) r - 1, 
  393.      (Screencoord) b, (Screencoord) t - 1);
  394.  
  395.     /*Set up an orthographic perspective setup to map to this viewport*/
  396.     MakeOrthoXform();
  397.     }
  398. #endif
  399. }
  400.  
  401. void RestoreDrawingWindow()
  402. /*Restores the window area to what it was before.  Side effect--sets the
  403.   window*/
  404. {
  405.     /*Pop the drawing state*/
  406.     PopDrawingState();
  407.     EchoDraw("RestoreDrawingWIndow");
  408. }
  409.  
  410. #ifdef PROTO
  411. void SetSubPort(int l, int r, int b, int t)
  412. #else
  413. void SetSubPort(l, r, b, t)
  414. int l, r, b, t;
  415. #endif
  416. /*Sets to draw into a subport.  Side effect--selects the window*/
  417. {
  418.     int k;
  419.  
  420.     EchoDraw("SetSubPort");
  421.  
  422.     /*Save the current state.*/
  423.     PushDrawingState();
  424.  
  425.     /*Pretend its a new window*/
  426.     CURSTATE . initialWindow = true;
  427.  
  428.     /*Save the bounds as the viewport*/
  429.     CURSTATE . viewport[0] = l;
  430.     CURSTATE . viewport[1] = r;
  431.     CURSTATE . viewport[2] = b;
  432.     CURSTATE . viewport[3] = t;
  433.  
  434.     /*Shift the mask over by the effective offset*/
  435.     CURSTATE . screenMask[0] -= CURSTATE . translation[0];
  436.     CURSTATE . screenMask[1] -= CURSTATE . translation[0];
  437.     CURSTATE . screenMask[2] -= CURSTATE . translation[1];
  438.     CURSTATE . screenMask[3] -= CURSTATE . translation[1];
  439.  
  440.     /*Make a screen mask that is the intersection*/
  441.     if (CURSTATE . viewport[0] > CURSTATE . screenMask[0])
  442.     CURSTATE . screenMask[0] = CURSTATE . viewport[0];
  443.     if (CURSTATE . viewport[1] < CURSTATE . screenMask[1])
  444.     CURSTATE . screenMask[1] = CURSTATE . viewport[1];
  445.     if (CURSTATE . viewport[2] > CURSTATE . screenMask[2])
  446.     CURSTATE . screenMask[2] = CURSTATE . viewport[2];
  447.     if (CURSTATE . viewport[3] < CURSTATE . screenMask[3])
  448.     CURSTATE . screenMask[3] = CURSTATE . viewport[3];
  449.  
  450.     /*Zero translation*/
  451.     for (k = 0; k < 2; ++k)
  452.     {
  453.     CURSTATE . translation[k] = 0;
  454.     }
  455.  
  456.     /*Bump up origin*/
  457.     CURSTATE . origin[0] += l;
  458.     CURSTATE . origin[1] += b;
  459.  
  460.     /*Save the bounds as the viewport and mask*/
  461.     CURSTATE . screenMask[0] = CURSTATE . viewport[0] = l;
  462.     CURSTATE . screenMask[1] = CURSTATE . viewport[1] = r;
  463.     CURSTATE . screenMask[2] = CURSTATE . viewport[2] = b;
  464.     CURSTATE . screenMask[3] = CURSTATE . viewport[3] = t;
  465.  
  466. #ifdef GRAPHICS
  467.     if (drawingMode == DRAW_SCREEN)
  468.     {
  469.     /*Set the viewport in pixel-centered coordinates*/
  470.     viewport((Screencoord) l, (Screencoord) r - 1, 
  471.          (Screencoord) b, (Screencoord) t - 1);
  472.  
  473.     /*Set up an orthographic perspective setup to map to this viewport*/
  474.     MakeOrthoXform();
  475.  
  476.     /*Set the screen mask*/
  477.     scrmask((Screencoord) CURSTATE . screenMask[0],
  478.         (Screencoord) CURSTATE . screenMask[1] - 1, 
  479.         (Screencoord) CURSTATE . screenMask[2],
  480.         (Screencoord) CURSTATE . screenMask[3] - 1);
  481.     }
  482.     else if (drawingMode == DRAW_POSTSCRIPT && psFile)
  483.     {
  484.     fprintf(psFile, "%%Call to SetSubPort!\n");
  485.     }
  486. #endif
  487. }
  488.  
  489. void RestoreSubPort()
  490. /*Restores the window area to what it was before.  Side effect--sets the
  491.   window*/
  492. {
  493.     /*Pop the drawing state*/
  494.     PopDrawingState();
  495.     EchoDraw("RestoreSubPort");
  496. }
  497.  
  498. #ifdef PROTO
  499. void SetOrthoPick(void)
  500. #else
  501. void SetOrthoPick()
  502. #endif
  503. /*Sets to do an ortho pick.*/
  504. {
  505.     int k;
  506.  
  507.     EchoDraw("SetOrthoPick");
  508.  
  509.     /*Save the current state.*/
  510.     PushDrawingState();
  511.  
  512.     /*Pretend its a new window*/
  513.     CURSTATE . initialWindow = true;
  514. }
  515.  
  516. #ifdef PROTO
  517. void RestoreOrthoPick(void)
  518. #else
  519. void RestoreOrthoPick()
  520. #endif
  521. /*Restores the pickiness to what it was before.  Side effect--sets the
  522.   window*/
  523. {
  524.     /*Pop the drawing state*/
  525.     PopDrawingState();
  526.     EchoDraw("RestoreOrthoPick");
  527. }
  528.  
  529. void SetOrigin(x, y)
  530. int x, y;
  531. /*Sets the origin to x, y WITHIN current translation*/
  532. {
  533.     EchoDraw("SetOrigin");
  534.     /*Save drawing state*/
  535.     PushDrawingState();
  536.   
  537.     CURSTATE . translation[0] += x;
  538.     CURSTATE . translation[1] += y;
  539.  
  540.     if (drawingMode == DRAW_SCREEN)
  541.     {
  542. #ifdef GRAPHICS
  543.     translate((Coord) x, (Coord) y, (Coord) 0.0);
  544. #endif
  545.     }
  546.     else if (drawingMode == DRAW_POSTSCRIPT && psFile)
  547.     {
  548.         fprintf(psFile, "%d %d translate\n", x, y);
  549.     }
  550. }
  551.  
  552. void RestoreOrigin()
  553. /*Restores the origin to what it was*/
  554. {
  555.     PopDrawingState();
  556.     EchoDraw("RestoreOrigin");
  557. }
  558.  
  559. #ifdef PROTO
  560. void FullScreen(Bool whether)
  561. #else
  562. void FullScreen(whether)
  563. Bool whether;
  564. #endif
  565. /*Sets full screen mode to whether*/
  566. {
  567.     if (whether == fullScreen) return;
  568.  
  569.     fullScreen = whether;
  570.  
  571. #ifdef GRAPHICS
  572.     if (fullScreen)
  573.     {
  574.     fullscrn();
  575.     }
  576.     else
  577.     {
  578.     endfullscrn();
  579.     }
  580. #endif
  581. }
  582.  
  583. void MakeOrthoXform()
  584. /*Makes an orthographic transformation based on the current state.*/
  585. {
  586.     if (drawingMode == DRAW_SCREEN)
  587.     {
  588. #ifdef GRAPHICS
  589.     mmode(MPROJECTION);
  590.     ortho2( 0.0,
  591.         (float) (CURSTATE . viewport[1] - CURSTATE . viewport[0]),
  592.         0.0,
  593.         (float) (CURSTATE . viewport[3] - CURSTATE . viewport[2]));
  594.     mmode(MVIEWING);
  595.     loadmatrix(Identity);
  596.  
  597.     translate((Coord) CURSTATE . translation[0],
  598.           (Coord) CURSTATE . translation[1], (Coord) 0.0);
  599. #endif
  600.     }
  601. }
  602.  
  603. void MakePickOrthoXform()
  604. /*Makes an orthographic transformation based on the current state.*/
  605. {
  606. #ifdef GRAPHICS
  607.     ortho2( 0.0,
  608.         (float) (CURSTATE . viewport[1] - CURSTATE . viewport[0]),
  609.         0.0,
  610.         (float) (CURSTATE . viewport[3] - CURSTATE . viewport[2]));
  611. #endif
  612. }
  613.  
  614. #ifdef PROTO
  615. void SetClipRect(int left, int right, int bottom, int top)
  616. #else
  617. void SetClipRect(left, right, bottom, top)
  618. int left, right, bottom, top;
  619. #endif
  620. /*Sets the current clipping rectangle to left, right, bottom, top*/
  621. {
  622.     int sl, sr, sb, st;
  623.  
  624.     EchoDraw("SetClipRect");
  625.  
  626.     /*Save the current state*/
  627.     PushDrawingState();
  628.  
  629.     left += CURSTATE . translation[0];
  630.     right += CURSTATE . translation[0];
  631.     bottom += CURSTATE . translation[1];
  632.     top += CURSTATE . translation[1];
  633.  
  634.     sl = CURSTATE . screenMask[0];
  635.     sr = CURSTATE . screenMask[1];
  636.     sb = CURSTATE . screenMask[2];
  637.     st = CURSTATE . screenMask[3];
  638.  
  639.     if (left > sl) sl = MIN(left, sr);
  640.     if (right < sr) sr = MAX(right, sl);
  641.     if (bottom > sb) sb = MIN(bottom, st);
  642.     if (top < st) st = MAX(top, sb);
  643.  
  644.     CURSTATE . screenMask[0] = sl;
  645.     CURSTATE . screenMask[1] = sr;
  646.     CURSTATE . screenMask[2] = sb;
  647.     CURSTATE . screenMask[3] = st;
  648.  
  649.     if (drawingMode == DRAW_SCREEN)
  650.     {
  651. #ifdef GRAPHICS
  652.     scrmask(sl, sr - 1, sb, st - 1);
  653. #endif
  654.     }
  655.     else if (drawingMode == DRAW_POSTSCRIPT && psFile)
  656.     {
  657.         fprintf(psFile,
  658. "resetclip newpath %d %d moveto %d %d lineto %d %d lineto %d %d lineto closepath clip newpath\n",
  659.         sl, st, sr, st, sr, sb, sl, sb);
  660.     }
  661. }
  662.  
  663. void RestoreClipRect()
  664. /*Restores the clipping rectangle to what it was before*/
  665. {
  666.     PopDrawingState();
  667.     EchoDraw("RestoreClipRect");
  668. }
  669.  
  670. void CurOffset(x, y)
  671. int *x, *y;
  672. /*Returns the current offset of the internal mouse coords from global*/
  673. {
  674.     int ox, oy;
  675.  
  676.     *x = CURSTATE . origin[0] + CURSTATE . translation[0];
  677.     *y = CURSTATE . origin[1] + CURSTATE . translation[1];
  678. }
  679.  
  680. void UD(void)
  681. /*Updated drawing according to belated DrawMe's*/
  682. {
  683. #ifdef GRAPHICS
  684.     if (drawMouse)
  685.     {
  686.     IdleAllWindows();
  687.     drawMouse = false;
  688.     }
  689. #endif
  690. }
  691.  
  692. void UpdateDrawing(void)
  693. /*Updates drawing according to belated DrawMe's*/
  694. {
  695.    UD();
  696. }
  697.  
  698. #ifdef GRAPHICS
  699. void DrawObj2(origObj, obj)
  700. ObjPtr origObj, obj;
  701. /*Draws origObj according to method in obj*/
  702. {
  703.     FuncTyp DrawFunction;            /*Method*/
  704.  
  705.     if (obj)
  706.     {
  707.     DrawObj2(origObj, ClassOf(obj));
  708.     DrawFunction = Get1Method(obj, DRAW);
  709.     if (DrawFunction)
  710.     {
  711.         (*DrawFunction)(origObj);
  712.     }
  713.     }
  714. }
  715. #endif
  716.  
  717. void DrawObject(obj)
  718. ObjPtr obj;
  719. /*Draws obj.*/
  720. {
  721. #ifdef GRAPHICS
  722.     ObjPtr picState;
  723.  
  724.     if (GetPredicate(obj, INHIBITDRAWING))
  725.     {
  726.     return;
  727.     }
  728.  
  729.     if (GetPredicate(obj, HIDDEN))
  730.     {
  731.     return;
  732.     }
  733.  
  734.     if (GetPredicate(obj, MULTIDRAW))
  735.     {
  736.     DrawObj2(obj, obj);
  737.     }
  738.     else
  739.     {
  740.     FuncTyp DrawFunction;            /*Method*/
  741.  
  742.     DrawFunction = GetMethod(obj, DRAW);
  743.     if (DrawFunction)
  744.     {
  745.         (*DrawFunction)(obj);
  746.     }
  747.     }
  748. #endif
  749. }
  750.  
  751. void ClipToMe(object)
  752. ObjPtr object;
  753. /*Sets the clipping rectangle to object*/
  754. {
  755.     int l, r, b, t;
  756.  
  757.     Get2DIntBounds(object, &l, &r, &b, &t);
  758.  
  759.     SetClipRect(l, r, b, t);
  760. }
  761.  
  762. #ifdef INTERACTIVE
  763. ObjPtr PressObject(obj, x, y, flags)
  764. ObjPtr obj;
  765. int x, y;
  766. long flags;
  767. /*Presses in obj at x, y*/
  768. {
  769.     FuncTyp PressFunction;
  770.     PressFunction = GetMethod(obj, PRESS);
  771.     if (PressFunction)
  772.     {
  773.     return (*PressFunction)(obj, x, y, flags);
  774.     }
  775.     else
  776.     {
  777.     return ObjFalse;
  778.     }
  779. }
  780. #endif
  781.  
  782. ObjPtr DropObjects(obj, dropObj, x, y)
  783. ObjPtr obj, dropObj;
  784. int x, y;
  785. /*Drops objects in list dropObj in obj at x, y*/
  786. {
  787.     FuncTyp method;
  788.     method = GetMethod(obj, DROPOBJECTS);
  789.     if (method)
  790.     {
  791.     return (*method)(obj, dropObj, x, y);
  792.     }
  793.     else
  794.     {
  795.     return ObjFalse;
  796.     }
  797. }
  798.  
  799. #ifdef PROTO
  800. ObjPtr KeyDownObject(ObjPtr obj, int key, long flags)
  801. #else
  802. ObjPtr KeyDownObject(obj, key, flags)
  803. ObjPtr obj;
  804. int key;
  805. long flags;
  806. #endif
  807. /*Does a keydown in obj*/
  808. {
  809.     FuncTyp method;
  810.     method = GetMethod(obj, KEYDOWN);
  811.     if (method)
  812.     {
  813.     return (*method)(obj, key, flags);
  814.     }
  815.     else
  816.     {
  817.     return ObjFalse;
  818.     }
  819. }
  820.  
  821. void FrameUIRect(left, right, bottom, top, uiColor)
  822. int left, right, bottom, top, uiColor;
  823. /*Frames a user interface rectangle*/
  824. {
  825. #ifdef GRAPHICS
  826.     SetUIColor(uiColor);
  827.     FrameRect(left, right, bottom, top);
  828. #endif
  829. }
  830.  
  831. void FrameRect(left, right, bottom, top)
  832. int left, right, bottom, top;
  833. /*Frames a rectangle*/
  834. {
  835. #ifdef GRAPHICS
  836.  
  837.     if (drawingMode == DRAW_SCREEN)
  838.     {
  839. #ifdef V3FISBUGGED
  840.     move2(left + 0.5, top - 0.5);
  841.     draw2(left + 0.5, bottom + 0.5);
  842.     draw2(right - 0.5, bottom + 0.5);
  843.     draw2(right - 0.5, top - 0.5);
  844.     draw2(left + 0.5, top - 0.5);
  845. #else
  846.     float v[5][2];
  847.     v[0][0] = left + 0.5;
  848.     v[0][1] = top - 0.5;
  849.     v[1][0] = left + 0.5;
  850.     v[1][1] = bottom + 0.5;
  851.     v[2][0] = right - 0.5;
  852.     v[2][1] = bottom + 0.5;
  853.     v[3][0] = right - 0.5;
  854.     v[3][1] = top - 0.5;
  855.     v[4][0] = left + 0.5;
  856.     v[4][1] = top - 0.5;
  857.     bgnline();
  858.     v2f(v[0]);
  859.     v2f(v[1]);
  860.     v2f(v[2]);
  861.     v2f(v[3]);
  862.     v2f(v[4]);
  863.     endline();
  864. #endif
  865.     }
  866.     else if (drawingMode == DRAW_POSTSCRIPT && psFile)
  867.     {
  868.     fprintf(psFile, "%f setgray\n", PSColor());
  869.         fprintf(psFile, "%d %d moveto %d %d lineto %d %d lineto %d %d lineto closepath stroke\n",
  870.             left, top, right, top, right, bottom, left, bottom); 
  871.     }
  872. #endif
  873. }
  874.  
  875. void FillUIRect(left, right, bottom, top, uiColor)
  876. int left, right, bottom, top, uiColor;
  877. /*Fills a user interface rectangle*/
  878. {
  879. #ifdef GRAPHICS
  880.  
  881.     SetUIColor(uiColor);
  882.     FillRect(left, right, bottom, top);
  883. #endif
  884. }
  885.  
  886. void FillRect(left, right, bottom, top)
  887. int left, right, bottom, top;
  888. /*Fills a rectangle*/
  889. {
  890. #ifdef GRAPHICS
  891.     FillIntQuad(left, bottom,
  892.          (right), bottom,
  893.          (right), (top),
  894.          left, (top));
  895. #endif
  896. }
  897.  
  898. void FillUIGauzeDisc(x, y, radius, uiColor)
  899. int x, y, radius, uiColor;
  900. /*Fills a disc in uiColor with gauze pattern*/
  901. {
  902. #ifdef GRAPHICS
  903.     SetUIColor(uiColor);
  904.     BeginTranslucent();
  905.     circfi(x, y, radius);
  906.     EndTranslucent();
  907. #endif
  908. }
  909.  
  910. void FillUIDisc(x, y, radius, uiColor)
  911. int x, y, radius, uiColor;
  912. /*Fills a disc in uiColor*/
  913. {
  914. #ifdef GRAPHICS
  915.     SetUIColor(uiColor);
  916.     if (drawingMode == DRAW_SCREEN)
  917.     {
  918.         circfi(x, y, radius);
  919.     }
  920.     else if (drawingMode == DRAW_POSTSCRIPT && psFile)
  921.     {
  922.     fprintf(psFile, "%f setgray\n", PSColor());
  923.         fprintf(psFile, "newpath %d %d %d 0 360 arc fill\n", x, y, radius);
  924.     }
  925. #endif
  926. }
  927.  
  928. void FillTri(x1, y1, x2, y2, x3, y3)
  929. int x1, y1, x2, y2, x3, y3;
  930. /*Fills a triangle*/
  931. {
  932. #ifdef GRAPHICS
  933.  
  934.     if (drawingMode == DRAW_SCREEN)
  935.     {
  936.     float v[3][2];
  937.     v[0][0] = x1;
  938.     v[0][1] = y1;
  939.     v[1][0] = x2;
  940.     v[1][1] = y2;
  941.     v[2][0] = x3;
  942.     v[2][1] = y3;
  943.     bgnpolygon();
  944.     v2f(v[0]);
  945.     v2f(v[1]);
  946.     v2f(v[2]);
  947.     endpolygon();
  948.     }
  949.     else if (drawingMode == DRAW_POSTSCRIPT && psFile)
  950.     {
  951.     fprintf(psFile, "%f setgray\n", PSColor());
  952.         fprintf(psFile, "%d %d moveto %d %d lineto %d %d lineto closepath fill\n",
  953.             x1, y1, x2, y2, x3, y3); 
  954.     }
  955. #endif
  956. }
  957.  
  958. void FillUITri(x1, y1, x2, y2, x3, y3, uiColor)
  959. int x1, y1, x2, y2, x3, y3, uiColor;
  960. /*Fills a triangle in uiColor*/ 
  961. { 
  962. #ifdef GRAPHICS 
  963.     SetUIColor(uiColor);
  964.     FillTri(x1, y1, x2, y2, x3, y3);
  965. #endif
  966. }
  967.  
  968. void FillUIGauzeRect(left, right, bottom, top, uiColor)
  969. int left, right, bottom, top, uiColor;
  970. /*Fills a user interface rectangle as if it were gauze*/
  971. {
  972. #ifdef GRAPHICS
  973.  
  974.     SetUIColor(uiColor);
  975.     BeginTranslucent();
  976.     FillIntQuad(left, (top),
  977.          left, bottom,
  978.          (right), bottom,
  979.          (right), (top));
  980.     EndTranslucent();
  981. #endif
  982. }
  983.  
  984. void DrawUILine(x1, y1, x2, y2, uiColor)
  985. int x1, y1, x2, y2, uiColor;
  986. {
  987. #ifdef GRAPHICS
  988.  
  989.     SetUIColor(uiColor);
  990.     DrawLine(x1, y1, x2, y2);
  991. #endif
  992. }
  993.  
  994. void DrawLine(x1, y1, x2, y2)
  995. int x1, y1, x2, y2;
  996. {
  997. #ifdef GRAPHICS
  998.     if (drawingMode == DRAW_SCREEN)
  999.     {
  1000. #ifdef V3FISBUGGED
  1001.     move2(x1 + 0.5, y1 + 0.5);
  1002.     draw2(x2 + 0.5, y2 + 0.5);
  1003. #else
  1004.     float v[2][2];
  1005.     v[0][0] = x1 + 0.5;
  1006.     v[0][1] = y1 + 0.5;
  1007.     v[1][0] = x2 + 0.5;
  1008.     v[1][1] = y2 + 0.5;
  1009.     bgnline();
  1010.     v2f(v[0]);
  1011.     v2f(v[1]);
  1012.     endline();
  1013. #endif
  1014.     }
  1015.     else if (drawingMode == DRAW_POSTSCRIPT && psFile)
  1016.     {
  1017.     fprintf(psFile, "%f setgray\n", PSColor());
  1018.         fprintf(psFile, "%d %d moveto %d %d lineto stroke\n",
  1019.             x1, y1, x2, y2);
  1020.     }
  1021. #endif
  1022. }
  1023.  
  1024. void FillUIWedge(x, y, radius, start, end, uiColor)
  1025. int x, y, radius, start, end, uiColor;
  1026. /*Fills a solid wege at x, y with radius from start to end degrees*/
  1027. {
  1028. #ifdef GRAPHICS
  1029.     SetUIColor(uiColor);
  1030.     if (drawingMode == DRAW_SCREEN)
  1031.     {
  1032.     arcfi(x, y, radius, start * 10, end * 10);
  1033.     }
  1034.     else if (drawingMode == DRAW_POSTSCRIPT && psFile)
  1035.     {
  1036.     fprintf(psFile, "%f setgray\n", PSColor());
  1037.     fprintf(psFile, "newpath %d %d moveto %d %d %d %d %d arc closepath fill\n", 
  1038.         x, y, x, y, radius, start, end);
  1039.     }
  1040. #endif
  1041. }
  1042.  
  1043. void DrawArc(x, y, radius, start, end)
  1044. int x, y, radius, start, end;
  1045. /*Draws an arc in the current color.  start and end are in degrees.*/
  1046. {
  1047.     if (drawingMode == DRAW_SCREEN)
  1048.     {
  1049. #ifdef GRAPHICS
  1050.     arci(x, y, radius, start * 10, end * 10);
  1051. #endif
  1052.     }
  1053.     else if (drawingMode == DRAW_POSTSCRIPT && psFile)
  1054.     {
  1055.     fprintf(psFile, "%f setgray\n", PSColor());
  1056.     fprintf(psFile, "newpath %d %d %d %d %d arc stroke\n", 
  1057.         x, y, radius, start, end);
  1058.     }
  1059. }
  1060.  
  1061. #ifdef PROTO
  1062. void FillSpaceRect(real x1, real y1, real z1,
  1063.            real x2, real y2, real z2,
  1064.            real x3, real y3, real z3,
  1065.            real x4, real y4, real z4,
  1066.            real nx, real ny, real nz)
  1067. #else
  1068. void FillSpaceRect( x1,  y1,  z1,
  1069.             x2,  y2,  z2,
  1070.             x3,  y3,  z3,
  1071.             x4,  y4,  z4,
  1072.             nx,  ny,  nz)
  1073. real x1; real y1; real z1;
  1074. real x2; real y2; real z2;
  1075. real x3; real y3; real z3;
  1076. real x4; real y4; real z4;
  1077. real nx; real ny; real nz;
  1078. #endif
  1079. /*Draws a rectangle in space around [xyz]1 through [xyz]4 using n[xyz]
  1080.   as normal.  If n[xyz] is 0, doesn't do a normal*/
  1081. {
  1082. #ifdef GRAPHICS
  1083.     float v[4][3];
  1084.     float n[3];
  1085.  
  1086.     v[0][0] = x1;
  1087.     v[0][1] = y1;
  1088.     v[0][2] = z1;
  1089.     v[1][0] = x2;
  1090.     v[1][1] = y2;
  1091.     v[1][2] = z2;
  1092.     v[2][0] = x3;
  1093.     v[2][1] = y3;
  1094.     v[2][2] = z3;
  1095.     v[3][0] = x4;
  1096.     v[3][1] = y4;
  1097.     v[3][2] = z4;
  1098.  
  1099.     if (nx != 0.0 || ny != 0.0 || nz != 0.0)
  1100.     {
  1101.     n[0] = nx;
  1102.     n[1] = ny;
  1103.     n[2] = nz;
  1104.     }
  1105.     bgnpolygon();
  1106.     N3F(n);
  1107.     v3f(v[0]);
  1108.     v3f(v[1]);
  1109.     v3f(v[2]);
  1110.     v3f(v[3]);
  1111.     endpolygon();
  1112. #endif
  1113. }
  1114.  
  1115. #ifdef PROTO
  1116. void FrameSpaceRect(real x1, real y1, real z1,
  1117.            real x2, real y2, real z2,
  1118.            real x3, real y3, real z3,
  1119.            real x4, real y4, real z4)
  1120. #else
  1121. void FrameSpaceRect( x1,  y1,  z1,
  1122.             x2,  y2,  z2,
  1123.             x3,  y3,  z3,
  1124.             x4,  y4,  z4)
  1125. real x1; real y1; real z1;
  1126. real x2; real y2; real z2;
  1127. real x3; real y3; real z3;
  1128. real x4; real y4; real z4;
  1129. #endif
  1130. /*Frames a rectangle in space around [xyz]1 through [xyz]4*/
  1131. {
  1132.     DrawSpaceLine(x1, y1, z1, x2, y2, z2);
  1133.     DrawSpaceLine(x2, y2, z2, x3, y3, z3);
  1134.     DrawSpaceLine(x3, y3, z3, x4, y4, z4);
  1135.     DrawSpaceLine(x4, y4, z4, x1, y1, z1);
  1136. }
  1137.  
  1138. #ifdef PROTO
  1139. void DrawSpaceLine(real x1, real y1, real z1, real x2, real y2, real z2)
  1140. #else
  1141. void DrawSpaceLine(x1, y1, z1, x1, y1, z1)
  1142. real x1; real y1; real z1;
  1143. real x2; real y2; real z2;
  1144. #endif
  1145. /*Draws a line in a space*/
  1146. {
  1147.     float v[2][3];
  1148. #ifdef GRAPHICS
  1149.  
  1150. #ifdef V3FISBUGGED
  1151.     move(x1, y1, z1);
  1152.     draw(x2, y2, z2);
  1153. #else
  1154.     /*Draws a line in a space*/
  1155.     v[0][0] = x1;
  1156.     v[0][1] = y1;
  1157.     v[0][2] = z1;
  1158.     v[1][0] = x2;
  1159.     v[1][1] = y2;
  1160.     v[1][2] = z2;
  1161.     bgnline();
  1162.     v3f(v[0]);
  1163.     v3f(v[1]);
  1164.     endline();
  1165. #endif
  1166. #endif
  1167. }
  1168.  
  1169. #ifdef PROTO
  1170. void DrawSpacePanelLine(real x1, real y1, real x2, real y2, real width, int arrow,
  1171.                 real arrowParams[4][2])
  1172. #else
  1173. void DrawSpacePanelLine(x1, y1, x2, y2, width, arrow, arrowParams)
  1174. real x1, y1, x2, y2, width;
  1175. int arrow;
  1176. real arrowParams[4][2];
  1177. #endif
  1178. /*Draws a space panel line*/
  1179. /* DIK need to make PostScript version */
  1180. {
  1181. #ifdef GRAPHICS
  1182.     if (x1 == y1 && x2 == y2)
  1183.     {
  1184.     /*Just a point*/
  1185.     long v[2];
  1186.  
  1187.     bgnpoint();
  1188.     v[0] = x1;
  1189.     v[1] = y1;
  1190.     v2i(v);
  1191.     endpoint();
  1192.     }
  1193.     else if (width <= 1 && arrow == AH_NO_ARROW)
  1194.     {
  1195.     /*Plain line*/
  1196.     long v[2][2];
  1197.  
  1198.     v[0][0] = x1;
  1199.     v[0][1] = y1;
  1200.     v[1][0] = x2;
  1201.     v[1][1] = y2;
  1202.     bgnline();
  1203.     v2i(v[0]);
  1204.     v2i(v[1]);
  1205.     endline();
  1206.     }
  1207.     else
  1208.     {
  1209.     /*Solid line*/
  1210.     real ax, ay, nx, ny, rr, mx, my;
  1211.     float v[10][2];
  1212.  
  1213.     /*Calculate the axial unit vector*/
  1214.     ax = x2 - x1;
  1215.     ay = y2 - y1;
  1216.     rr = 1.0 / sqrt(ax * ax + ay * ay);
  1217.     ax *= rr;
  1218.     ay *= rr;
  1219.  
  1220.     /*Now the normal unit vector*/
  1221.     nx = -ay;
  1222.     ny = ax;
  1223.  
  1224.     switch(arrow)
  1225.     {
  1226.         case AH_NO_ARROW:
  1227.         v[0][0] = x1 - nx * width * 0.5;
  1228.         v[0][1] = y1 - ny * width * 0.5; 
  1229.         v[1][0] = x2 - nx * width * 0.5;
  1230.         v[1][1] = y2 - ny * width * 0.5; 
  1231.         v[2][0] = x2 + nx * width * 0.5;
  1232.         v[2][1] = y2 + ny * width * 0.5; 
  1233.         v[3][0] = x1 + nx * width * 0.5;
  1234.         v[3][1] = y1 + ny * width * 0.5; 
  1235.             bgnpolygon();
  1236.         v2f(v[0]);
  1237.         v2f(v[1]);
  1238.         v2f(v[2]);
  1239.         v2f(v[3]);
  1240.         endpolygon();
  1241.         break;
  1242.         case AH_AT_END:
  1243.  
  1244.         /*Arrow base*/
  1245.         v[0][0] = x1;
  1246.         v[0][1] = y1;
  1247.  
  1248.         /*Down to fletching*/
  1249.         v[1][0] = x1 + ax * width * arrowParams[0][0] -
  1250.                  nx * width * arrowParams[0][1];
  1251.         v[1][1] = y1 + ay * width * arrowParams[0][0] -
  1252.                  ny * width * arrowParams[0][1];
  1253.  
  1254.         /*Over to shaft*/
  1255.         v[2][0] = x2 + ax * width * arrowParams[1][0] -
  1256.                  nx * width * arrowParams[1][1];
  1257.         v[2][1] = y2 + ay * width * arrowParams[1][0] -
  1258.                  ny * width * arrowParams[1][1];
  1259.  
  1260.         /*To first arrowhead tip*/
  1261.         v[3][0] = x2 + ax * width * arrowParams[2][0] -
  1262.                  nx * width * arrowParams[2][1];
  1263.         v[3][1] = y2 + ay * width * arrowParams[2][0] -
  1264.                  ny * width * arrowParams[2][1];
  1265.  
  1266.         /*To second arrowhead tip*/
  1267.         v[4][0] = x2 + ax * width * arrowParams[3][0] -
  1268.                  nx * width * arrowParams[3][1];
  1269.         v[4][1] = y2 + ay * width * arrowParams[3][0] -
  1270.                  ny * width * arrowParams[3][1];
  1271.  
  1272.         /*To end of arrow*/
  1273.         v[5][0] = x2;
  1274.         v[5][1] = y2;
  1275.  
  1276.         /*Up to second arrowhead tip*/
  1277.         v[6][0] = x2 + ax * width * arrowParams[3][0] +
  1278.                  nx * width * arrowParams[3][1];
  1279.         v[6][1] = y2 + ay * width * arrowParams[3][0] +
  1280.                  ny * width * arrowParams[3][1];
  1281.  
  1282.         /*Back to first arrowhead tip*/
  1283.         v[7][0] = x2 + ax * width * arrowParams[2][0] +
  1284.                  nx * width * arrowParams[2][1];
  1285.         v[7][1] = y2 + ay * width * arrowParams[2][0] +
  1286.                  ny * width * arrowParams[2][1];
  1287.  
  1288.         /*Down to shaft*/
  1289.         v[8][0] = x2 + ax * width * arrowParams[1][0] +
  1290.                  nx * width * arrowParams[1][1];
  1291.         v[8][1] = y2 + ay * width * arrowParams[1][0] +
  1292.                  ny * width * arrowParams[1][1];
  1293.  
  1294.         /*Back to fletching*/
  1295.         v[9][0] = x1 + ax * width * arrowParams[0][0] +
  1296.                  nx * width * arrowParams[0][1];
  1297.         v[9][1] = y1 + ay * width * arrowParams[0][0] +
  1298.                  ny * width * arrowParams[0][1];
  1299.  
  1300.             bgnpolygon();
  1301.         v2f(v[0]);
  1302.         v2f(v[1]);
  1303.         v2f(v[2]);
  1304.         v2f(v[3]);
  1305.         v2f(v[4]);
  1306.         v2f(v[5]);
  1307.         v2f(v[6]);
  1308.         v2f(v[7]);
  1309.         v2f(v[8]);
  1310.         v2f(v[9]);
  1311.         endpolygon();
  1312.         break;
  1313.         case AH_AT_START:
  1314.  
  1315.         /*Arrow base*/
  1316.         v[0][0] = x2;
  1317.         v[0][1] = y2;
  1318.  
  1319.         /*Down to fletching*/
  1320.         v[1][0] = x2 - ax * width * arrowParams[0][0] +
  1321.                  nx * width * arrowParams[0][1];
  1322.         v[1][1] = y2 - ay * width * arrowParams[0][0] +
  1323.                  ny * width * arrowParams[0][1];
  1324.  
  1325.         /*Over to shaft*/
  1326.         v[2][0] = x1 - ax * width * arrowParams[1][0] +
  1327.                  nx * width * arrowParams[1][1];
  1328.         v[2][1] = y1 - ay * width * arrowParams[1][0] +
  1329.                  ny * width * arrowParams[1][1];
  1330.  
  1331.         /*To first arrowhead tip*/
  1332.         v[3][0] = x1 - ax * width * arrowParams[2][0] +
  1333.                  nx * width * arrowParams[2][1];
  1334.         v[3][1] = y1 - ay * width * arrowParams[2][0] +
  1335.                  ny * width * arrowParams[2][1];
  1336.  
  1337.         /*To second arrowhead tip*/
  1338.         v[4][0] = x1 - ax * width * arrowParams[3][0] +
  1339.                  nx * width * arrowParams[3][1];
  1340.         v[4][1] = y1 - ay * width * arrowParams[3][0] +
  1341.                  ny * width * arrowParams[3][1];
  1342.  
  1343.         /*To end of arrow*/
  1344.         v[5][0] = x1;
  1345.         v[5][1] = y1;
  1346.  
  1347.         /*Up to second arrowhead tip*/
  1348.         v[6][0] = x1 - ax * width * arrowParams[3][0] -
  1349.                  nx * width * arrowParams[3][1];
  1350.         v[6][1] = y1 - ay * width * arrowParams[3][0] -
  1351.                  ny * width * arrowParams[3][1];
  1352.  
  1353.         /*Back to first arrowhead tip*/
  1354.         v[7][0] = x1 - ax * width * arrowParams[2][0] -
  1355.                  nx * width * arrowParams[2][1];
  1356.         v[7][1] = y1 - ay * width * arrowParams[2][0] -
  1357.                  ny * width * arrowParams[2][1];
  1358.  
  1359.         /*Down to shaft*/
  1360.         v[8][0] = x1 - ax * width * arrowParams[1][0] -
  1361.                  nx * width * arrowParams[1][1];
  1362.         v[8][1] = y1 - ay * width * arrowParams[1][0] -
  1363.                  ny * width * arrowParams[1][1];
  1364.  
  1365.         /*Back to fletching*/
  1366.         v[9][0] = x2 - ax * width * arrowParams[0][0] -
  1367.                  nx * width * arrowParams[0][1];
  1368.         v[9][1] = y2 - ay * width * arrowParams[0][0] -
  1369.                  ny * width * arrowParams[0][1];
  1370.  
  1371.             bgnpolygon();
  1372.         v2f(v[0]);
  1373.         v2f(v[1]);
  1374.         v2f(v[2]);
  1375.         v2f(v[3]);
  1376.         v2f(v[4]);
  1377.         v2f(v[5]);
  1378.         v2f(v[6]);
  1379.         v2f(v[7]);
  1380.         v2f(v[8]);
  1381.         v2f(v[9]);
  1382.         endpolygon();
  1383.         break;
  1384.  
  1385.         case AH_BOTH_ENDS:
  1386.         /*Calculate midpoints*/
  1387.         mx = (x1 + x2) * 0.5;
  1388.         my = (y1 + y2) * 0.5;
  1389.  
  1390.         /*Do at end first*/
  1391.  
  1392.         /*Arrow base*/
  1393.         v[0][0] = mx;
  1394.         v[0][1] = my;
  1395.  
  1396.         /*Down to fletching*/
  1397.         v[1][0] = mx + ax * width * arrowParams[0][0] -
  1398.                  nx * width * arrowParams[0][1];
  1399.         v[1][1] = my + ay * width * arrowParams[0][0] -
  1400.                  ny * width * arrowParams[0][1];
  1401.  
  1402.         /*Over to shaft*/
  1403.         v[2][0] = x2 + ax * width * arrowParams[1][0] -
  1404.                  nx * width * arrowParams[1][1];
  1405.         v[2][1] = y2 + ay * width * arrowParams[1][0] -
  1406.                  ny * width * arrowParams[1][1];
  1407.  
  1408.         /*To first arrowhead tip*/
  1409.         v[3][0] = x2 + ax * width * arrowParams[2][0] -
  1410.                  nx * width * arrowParams[2][1];
  1411.         v[3][1] = y2 + ay * width * arrowParams[2][0] -
  1412.                  ny * width * arrowParams[2][1];
  1413.  
  1414.         /*To second arrowhead tip*/
  1415.         v[4][0] = x2 + ax * width * arrowParams[3][0] -
  1416.                  nx * width * arrowParams[3][1];
  1417.         v[4][1] = y2 + ay * width * arrowParams[3][0] -
  1418.                  ny * width * arrowParams[3][1];
  1419.  
  1420.         /*To end of arrow*/
  1421.         v[5][0] = x2;
  1422.         v[5][1] = y2;
  1423.  
  1424.         /*Up to second arrowhead tip*/
  1425.         v[6][0] = x2 + ax * width * arrowParams[3][0] +
  1426.                  nx * width * arrowParams[3][1];
  1427.         v[6][1] = y2 + ay * width * arrowParams[3][0] +
  1428.                  ny * width * arrowParams[3][1];
  1429.  
  1430.         /*Back to first arrowhead tip*/
  1431.         v[7][0] = x2 + ax * width * arrowParams[2][0] +
  1432.                  nx * width * arrowParams[2][1];
  1433.         v[7][1] = y2 + ay * width * arrowParams[2][0] +
  1434.                  ny * width * arrowParams[2][1];
  1435.  
  1436.         /*Down to shaft*/
  1437.         v[8][0] = x2 + ax * width * arrowParams[1][0] +
  1438.                  nx * width * arrowParams[1][1];
  1439.         v[8][1] = y2 + ay * width * arrowParams[1][0] +
  1440.                  ny * width * arrowParams[1][1];
  1441.  
  1442.         /*Back to fletching*/
  1443.         v[9][0] = mx + ax * width * arrowParams[0][0] +
  1444.                  nx * width * arrowParams[0][1];
  1445.         v[9][1] = my + ay * width * arrowParams[0][0] +
  1446.                  ny * width * arrowParams[0][1];
  1447.  
  1448.             bgnpolygon();
  1449.         v2f(v[0]);
  1450.         v2f(v[1]);
  1451.         v2f(v[2]);
  1452.         v2f(v[3]);
  1453.         v2f(v[4]);
  1454.         v2f(v[5]);
  1455.         v2f(v[6]);
  1456.         v2f(v[7]);
  1457.         v2f(v[8]);
  1458.         v2f(v[9]);
  1459.         endpolygon();
  1460.  
  1461.         /*Now do at start*/
  1462.             bgnpolygon();
  1463.  
  1464.         /*Arrow base*/
  1465.         v[0][0] = mx;
  1466.         v[0][1] = my;
  1467.  
  1468.         /*Down to fletching*/
  1469.         v[1][0] = mx - ax * width * arrowParams[0][0] +
  1470.                  nx * width * arrowParams[0][1];
  1471.         v[1][1] = my - ay * width * arrowParams[0][0] +
  1472.                  ny * width * arrowParams[0][1];
  1473.  
  1474.         /*Over to shaft*/
  1475.         v[2][0] = x1 - ax * width * arrowParams[1][0] +
  1476.                  nx * width * arrowParams[1][1];
  1477.         v[2][1] = y1 - ay * width * arrowParams[1][0] +
  1478.                  ny * width * arrowParams[1][1];
  1479.  
  1480.         /*To first arrowhead tip*/
  1481.         v[3][0] = x1 - ax * width * arrowParams[2][0] +
  1482.                  nx * width * arrowParams[2][1];
  1483.         v[3][1] = y1 - ay * width * arrowParams[2][0] +
  1484.                  ny * width * arrowParams[2][1];
  1485.  
  1486.         /*To second arrowhead tip*/
  1487.         v[4][0] = x1 - ax * width * arrowParams[3][0] +
  1488.                  nx * width * arrowParams[3][1];
  1489.         v[4][1] = y1 - ay * width * arrowParams[3][0] +
  1490.                  ny * width * arrowParams[3][1];
  1491.  
  1492.         /*To end of arrow*/
  1493.         v[5][0] = x1;
  1494.         v[5][1] = y1;
  1495.  
  1496.         /*Up to second arrowhead tip*/
  1497.         v[6][0] = x1 - ax * width * arrowParams[3][0] -
  1498.                  nx * width * arrowParams[3][1];
  1499.         v[6][1] = y1 - ay * width * arrowParams[3][0] -
  1500.                  ny * width * arrowParams[3][1];
  1501.         
  1502.         /*Back to first arrowhead tip*/
  1503.         v[7][0] = x1 - ax * width * arrowParams[2][0] -
  1504.                  nx * width * arrowParams[2][1];
  1505.         v[7][1] = y1 - ay * width * arrowParams[2][0] -
  1506.                  ny * width * arrowParams[2][1];
  1507.         
  1508.         /*Down to shaft*/
  1509.         v[8][0] = x1 - ax * width * arrowParams[1][0] -
  1510.                  nx * width * arrowParams[1][1];
  1511.         v[8][1] = y1 - ay * width * arrowParams[1][0] -
  1512.                  ny * width * arrowParams[1][1];
  1513.  
  1514.         /*Back to fletching*/
  1515.         v[9][0] = mx - ax * width * arrowParams[0][0] -
  1516.                  nx * width * arrowParams[0][1];
  1517.         v[9][1] = my - ay * width * arrowParams[0][0] -
  1518.                  ny * width * arrowParams[0][1];
  1519.  
  1520.             bgnpolygon();
  1521.         v2f(v[0]);
  1522.         v2f(v[1]);
  1523.         v2f(v[2]);
  1524.         v2f(v[3]);
  1525.         v2f(v[4]);
  1526.         v2f(v[5]);
  1527.         v2f(v[6]);
  1528.         v2f(v[7]);
  1529.         v2f(v[8]);
  1530.         v2f(v[9]);
  1531.         endpolygon();
  1532.         break;
  1533.     }    
  1534.     }
  1535. #endif
  1536. }
  1537.  
  1538. void DrawVCursor(x, yt, yb)
  1539. int x, yt, yb;
  1540. /*Draws a vertical cursor*/
  1541. {
  1542. #ifdef GRAPHICS
  1543.     DrawUILine(x, yt, x, yb, UIRED);
  1544.     DrawUILine(x + 1, yt, x + 1, yb, UIBLACK);
  1545. #endif
  1546. }
  1547.  
  1548. #ifdef GRAPHICS
  1549. #ifdef FONTS4D
  1550. extern fmfonthandle currentFontHandle;
  1551. #endif
  1552. #endif
  1553.  
  1554. #ifdef PROTO
  1555. void DrawSpaceString(real x, real y, real z, char *s)
  1556. #else
  1557. void DrawSpaceString(x, y, z, s)
  1558. real x, y, z;
  1559. char *s;
  1560. #endif
  1561. /*Draws a string beginning at x, y, z in a space*/
  1562. /* DIK need PostScript version? */
  1563. {
  1564. #ifdef GRAPHICS
  1565.  
  1566.     cmov((Coord) x, (Coord) y, (Coord) z);
  1567. #ifdef FONTS4D
  1568.     if (currentFontHandle)
  1569.     {
  1570.         fmprstr(s);
  1571.     }
  1572.     else
  1573.     {
  1574.         charstr(s);
  1575.     }
  1576. #else
  1577.     charstr(s);
  1578. #endif
  1579. #endif
  1580. }
  1581.  
  1582. #ifdef PROTO
  1583. void DrawWFSphere(real x, real y, real z, real radius)
  1584. #else
  1585. void DrawWFSphere(x, y, z, radius)
  1586. real x, y, z, radius;
  1587. #endif
  1588. /*Draws a wire frame sphere*/
  1589. {
  1590. #ifdef GRAPHICS
  1591.     pushmatrix();
  1592.     translate(x, y, z);
  1593.     circ(0.0, 0.0, radius);
  1594.     translate(0.0, 0.0, radius * SQ22);
  1595.     circ(0.0, 0.0, radius * SQ22);
  1596.     translate(0.0, 0.0, -radius * 2.0 * SQ22);
  1597.     circ(0.0, 0.0, radius * SQ22);
  1598.     translate(0.0, 0.0, radius * SQ22);
  1599.     rotate(900, 'y');
  1600.     circ(0.0, 0.0, radius);
  1601.     rotate(450, 'x');
  1602.     circ(0.0, 0.0, radius);
  1603.     rotate(450, 'x');
  1604.     circ(0.0, 0.0, radius);
  1605.     rotate(450, 'x');
  1606.     circ(0.0, 0.0, radius);
  1607.     popmatrix();
  1608. #endif
  1609. }
  1610.  
  1611. #ifdef PROTO
  1612. void FillRealQuad(real x1, real y1, real x2, real y2, real x3, real y3, real x4, real y4)
  1613. #else
  1614. void FillRealQuad(x1, y1, x2, y2, x3, y3, x4, y4)
  1615. real x1, y1, x2, y2, x3, y3, x4, y4;
  1616. #endif
  1617. /*Fills a quadrilateral given real coordinates*/
  1618. {
  1619. #ifdef GRAPHICS
  1620.     if (drawingMode == DRAW_SCREEN)
  1621.     {
  1622.     float v[4][2];
  1623.     v[0][0] = x1;
  1624.     v[0][1] = y1;
  1625.     v[1][0] = x2;
  1626.     v[1][1] = y2;
  1627.     v[2][0] = x3;
  1628.     v[2][1] = y3;
  1629.     v[3][0] = x4;
  1630.     v[3][1] = y4;
  1631.     bgnpolygon();
  1632.     v2f(v[0]);
  1633.     v2f(v[1]);
  1634.     v2f(v[2]);
  1635.     v2f(v[3]);
  1636.     endpolygon();
  1637.     }
  1638.     else if (drawingMode == DRAW_POSTSCRIPT && psFile)
  1639.     {
  1640.     fprintf(psFile, "%f setgray\n", PSColor());
  1641.         fprintf(psFile, "%g %g moveto %g %g lineto %g %g lineto %g %g lineto closepath fill\n",
  1642.             x1, y1, x2, y2, x3, y3, x4, y4); 
  1643.     }
  1644. #endif
  1645. }
  1646.  
  1647. #ifdef PROTO
  1648. void FillIntQuad(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4)
  1649. #else
  1650. void FillIntQuad(x1, y1, x2, y2, x3, y3, x4, y4)
  1651. int x1, y1, x2, y2, x3, y3, x4, y4;
  1652. #endif
  1653. /*Fills a quadrilateral given real coordinates*/
  1654. {
  1655. #ifdef GRAPHICS
  1656.     if (drawingMode == DRAW_SCREEN)
  1657.     {
  1658.     long v[4][2];
  1659.     v[0][0] = x1;
  1660.     v[0][1] = y1;
  1661.     v[1][0] = x2;
  1662.     v[1][1] = y2;
  1663.     v[2][0] = x3;
  1664.     v[2][1] = y3;
  1665.     v[3][0] = x4;
  1666.     v[3][1] = y4;
  1667.     bgnpolygon();
  1668.     v2i(v[0]);
  1669.     v2i(v[1]);
  1670.     v2i(v[2]);
  1671.     v2i(v[3]);
  1672.     endpolygon();
  1673.     }
  1674.     else if (drawingMode == DRAW_POSTSCRIPT && psFile)
  1675.     {
  1676.     fprintf(psFile, "%f setgray\n", PSColor());
  1677.         fprintf(psFile, "%d %d moveto %d %d lineto %d %d lineto %d %d lineto closepath fill\n",
  1678.             x1, y1, x2, y2, x3, y3, x4, y4); 
  1679.     }
  1680. #endif
  1681. }
  1682.  
  1683. #ifdef PROTO
  1684. void FillRealQuint(real x1, real y1, real x2, real y2, real x3, real y3, real x4, real y4, real x5, real y5)
  1685. #else
  1686. void FillRealQuint(x1, y1, x2, y2, x3, y3, x4, y4, x5, y5)
  1687. real x1, y1, x2, y2, x3, y3, x4, y4, x5, y5;
  1688. #endif
  1689. /*Fills a quintalateral given real coordinates*/
  1690. {
  1691. #ifdef GRAPHICS
  1692.     if (drawingMode == DRAW_SCREEN)
  1693.     {
  1694.     float v[5][2];
  1695.     v[0][0] = x1;
  1696.     v[0][1] = y1;
  1697.     v[1][0] = x2;
  1698.     v[1][1] = y2;
  1699.     v[2][0] = x3;
  1700.     v[2][1] = y3;
  1701.     v[3][0] = x4;
  1702.     v[3][1] = y4;
  1703.     v[4][0] = x5;
  1704.     v[4][1] = y5;
  1705.     bgnpolygon();
  1706.     v2f(v[0]);
  1707.     v2f(v[1]);
  1708.     v2f(v[2]);
  1709.     v2f(v[3]);
  1710.     v2f(v[4]);
  1711.     endpolygon();
  1712.     }
  1713.     else if (drawingMode == DRAW_POSTSCRIPT && psFile)
  1714.     {
  1715.     fprintf(psFile, "%f setgray\n", PSColor());
  1716.         fprintf(psFile, "%g %g moveto %g %g lineto %g %g lineto %g %g lineto %g %g lineto closepath fill\n",
  1717.             x1, y1, x2, y2, x3, y3, x4, y4, x5, y5); 
  1718.     }
  1719. #endif
  1720. }
  1721.  
  1722. #ifdef PROTO
  1723. void FillRealHex(real x1, real y1, real x2, real y2, real x3, real y3, real x4, real y4, real x5, real y5, real x6, real y6)
  1724. #else
  1725. void FillRealHex(x1, y1, x2, y2, x3, y3, x4, y4, x5, y5, x6, y6)
  1726. real x1, y1, x2, y2, x3, y3, x4, y4, x5, y5, x6, y6;
  1727. #endif
  1728. /*Fills a hexalateral given real coordinates*/
  1729. {
  1730. #ifdef GRAPHICS
  1731.     if (drawingMode == DRAW_SCREEN)
  1732.     {
  1733.     float v[6][2];
  1734.     v[0][0] = x1;
  1735.     v[0][1] = y1;
  1736.     v[1][0] = x2;
  1737.     v[1][1] = y2;
  1738.     v[2][0] = x3;
  1739.     v[2][1] = y3;
  1740.     v[3][0] = x4;
  1741.     v[3][1] = y4;
  1742.     v[4][0] = x5;
  1743.     v[4][1] = y5;
  1744.     v[5][0] = x6;
  1745.     v[5][1] = y6;
  1746.     bgnpolygon();
  1747.     v2f(v[0]);
  1748.     v2f(v[1]);
  1749.     v2f(v[2]);
  1750.     v2f(v[3]);
  1751.     v2f(v[4]);
  1752.     v2f(v[5]);
  1753.     endpolygon();
  1754.     }
  1755.     else if (drawingMode == DRAW_POSTSCRIPT && psFile)
  1756.     {
  1757.     fprintf(psFile, "%f setgray\n", PSColor());
  1758.         fprintf(psFile, "%g %g moveto %g %g lineto %g %g lineto %g %g lineto %g %g lineto %g %g lineto closepath fill\n",
  1759.             x1, y1, x2, y2, x3, y3, x4, y4, x5, y5, x6, y6); 
  1760.     }
  1761. #endif
  1762. }
  1763.  
  1764. #ifdef PROTO
  1765. void FillRealRect(real left, real right, real bottom, real top)
  1766. #else
  1767. void FillRealRect(left, right, bottom, top)
  1768. real left, right, bottom, top;
  1769. #endif
  1770. /*Fills a rectangle, taking real coordinates*/
  1771. {
  1772. #ifdef GRAPHICS
  1773.     FillRealQuad(left, top, left, bottom, right, bottom, right, top);
  1774. #endif
  1775. }
  1776.  
  1777.  
  1778. #ifdef PROTO
  1779. void FrameRealWideRect(real left, real right, real bottom, real top, real width)
  1780. #else
  1781. void FrameRealWideRect(left, right, bottom, top, width)
  1782. real left, right, bottom, top, width;
  1783. #endif
  1784. /*Frames a wide rectangle taking real variables*/
  1785. {
  1786. #ifdef GRAPHICS
  1787.     FillRealRect(left, right, top - width, top);
  1788.     FillRealRect(left, right, bottom, bottom + width);
  1789.     FillRealRect(left, left + width, bottom, top);
  1790.     FillRealRect(right - width, right, bottom, top);
  1791. #endif
  1792. }
  1793.  
  1794. #ifdef PROTO
  1795. void FrameWideRect(int left, int right, int bottom, int top, int width)
  1796. #else
  1797. void FrameWideRect(left, right, bottom, top, width)
  1798. int left, right, bottom, top, width;
  1799. #endif
  1800. /*Frames a wide rectangle*/
  1801. {
  1802. #ifdef GRAPHICS
  1803.     FillRect(left, right, top - width + 1, top);
  1804.     FillRect(left, right, bottom, bottom + width - 1);
  1805.     FillRect(left, left + width - 1, bottom, top);
  1806.     FillRect(right - width + 1, right, bottom, top);
  1807. #endif
  1808. }
  1809.  
  1810. #ifdef PROTO
  1811. void FrameUIWideRect(int left, int right, int bottom, int top, int width, int color)
  1812. #else
  1813. void FrameUIWideRect(left, right, bottom, top, width, color)
  1814. int left, right, bottom, top, width, color;
  1815. #endif
  1816. /*Frames a wide rectangle in UI color*/
  1817. {
  1818. #ifdef GRAPHICS
  1819.     SetUIColor(color);
  1820.     FrameWideRect(left, right, bottom, top, width);
  1821. #endif
  1822. }
  1823.  
  1824. #ifdef PROTO
  1825. void DrawHandle(int x, int y)
  1826. #else
  1827. void DrawHandle(x, y)
  1828. int x, y;
  1829. #endif
  1830. /* Draws a handle at x,y */
  1831. {
  1832. #ifdef GRAPHICS
  1833.     FillUIRect(x - HANDLESIZE/2, x + HANDLESIZE / 2,
  1834.         y - HANDLESIZE/2, y + HANDLESIZE/2, OUTSIDEFRAMECOLOR);
  1835.     FillUIRect(x - HANDLESIZE/2 + OUTSIDEFRAMEWEIGHT,
  1836.         x + HANDLESIZE/2 - OUTSIDEFRAMEWEIGHT,
  1837.         y - HANDLESIZE/2 + OUTSIDEFRAMEWEIGHT,
  1838.         y + HANDLESIZE/2 - OUTSIDEFRAMEWEIGHT, INSIDEFRAMECOLOR);
  1839. #endif
  1840. }
  1841.  
  1842. #ifdef PROTO
  1843. Bool PointInHandle(int pointX, int pointY, int handleX, int handleY)
  1844. #else
  1845. Bool PointInHandle(pointX, pointY, handleX, handleY)
  1846. int pointX; int pointY; int handleX; int handleY;
  1847. #endif
  1848. /*Returns true if a point is inside a handle*/
  1849. {
  1850. #ifdef INTERACTIVE
  1851.     return (pointX >= handleX - HANDLESIZE / 2 &&
  1852.         pointX <= handleX + HANDLESIZE / 2 &&
  1853.         pointY >= handleY - HANDLESIZE / 2 &&
  1854.         pointY <= handleY + HANDLESIZE / 2) ? true : false;
  1855. #endif
  1856. }
  1857.  
  1858. #ifdef PROTO
  1859. void DrawRaisedEdge(int left, int right, int bottom, int top)
  1860. #else
  1861. void DrawRaisedEdge(left, right, bottom, top)
  1862. int left; int right; int bottom; int top;
  1863. #endif
  1864. /* draws a rectangular raised edge (JEL) */
  1865. {
  1866. #ifdef GRAPHICS
  1867.     /* bottom */
  1868.     SetUIColor(UIBOTTOMEDGE);
  1869.     FillIntQuad( left, bottom,
  1870.          right, bottom,
  1871.          right - EDGE, bottom + EDGE,
  1872.          left + EDGE, bottom + EDGE);
  1873.  
  1874.     /* left */
  1875.     SetUIColor(UILEFTEDGE);
  1876.     FillIntQuad( left,  bottom,
  1877.          left + EDGE, bottom + EDGE,
  1878.          left + EDGE, top - EDGE,
  1879.          left, top);
  1880.  
  1881.     /* right */
  1882.     SetUIColor(UIRIGHTEDGE);
  1883.     FillIntQuad( right - EDGE, bottom + EDGE,
  1884.          right, bottom,
  1885.          right, top,
  1886.          right - EDGE, top - EDGE);
  1887.  
  1888.     /* top */
  1889.     SetUIColor(UITOPEDGE);
  1890.     FillIntQuad( left + EDGE, top - EDGE,
  1891.          right - EDGE, top - EDGE,
  1892.          right, top,
  1893.          left, top);
  1894.     return;
  1895. #endif
  1896. }
  1897.  
  1898. #ifdef PROTO
  1899. void DrawSunkenEdge(int left, int right, int bottom, int top)
  1900. #else
  1901. void DrawSunkenEdge(left, right, bottom, top)
  1902. int left; int right; int bottom; int top;
  1903. #endif
  1904. /* draws a rectanglar sunken edge (JEL) 
  1905.    Fixed to be in CCW order (EMP) */
  1906. {
  1907. #ifdef GRAPHICS
  1908.     /* bottom */
  1909.     SetUIColor(UITOPEDGE);
  1910.     FillIntQuad( left, bottom,
  1911.          right, bottom,
  1912.          right - EDGE, bottom + EDGE,
  1913.          left + EDGE, bottom + EDGE);
  1914.  
  1915.     /* left */
  1916.     SetUIColor(UIRIGHTEDGE);
  1917.     FillIntQuad( left,  bottom,
  1918.          left + EDGE, bottom + EDGE,
  1919.          left + EDGE, top - EDGE,
  1920.          left, top);
  1921.  
  1922.     /* right */
  1923.     SetUIColor(UILEFTEDGE);
  1924.     FillIntQuad( right - EDGE, bottom + EDGE,
  1925.          right, bottom,
  1926.          right, top,
  1927.          right - EDGE, top - EDGE);
  1928.  
  1929.     /* top */
  1930.     SetUIColor(UIBOTTOMEDGE);
  1931.     FillIntQuad( left + EDGE, top - EDGE,
  1932.          right - EDGE, top - EDGE,
  1933.          right, top,
  1934.          left, top);
  1935.     return;
  1936. #endif
  1937. }
  1938.  
  1939. #ifdef PROTO
  1940. void DrawInsetRect(int left, int right, int bottom, int top)
  1941. #else
  1942. void DrawInsetRect(left, right, bottom, top)
  1943. int left; int right; int bottom; int top;
  1944. #endif
  1945. /* draws a rectangle filled with uiColor inset by EDGE from the given bounds */
  1946. {
  1947. #ifdef GRAPHICS
  1948.     FillRect(left + EDGE, right - EDGE, bottom + EDGE,
  1949.         top - EDGE);
  1950. #endif
  1951. }
  1952.  
  1953. #ifdef PROTO
  1954. void DrawInsetWashedRect(int left, int right, int bottom, int top, int washColor)
  1955. #else
  1956. void DrawInsetWashedRect(left, right, bottom, top, int washColor)
  1957. int left; int right; int bottom; int top; int washColor;
  1958. #endif
  1959. /* draws a rectangle filled with uiColor inset by EDGE from the given bounds */
  1960. {
  1961. #ifdef GRAPHICS
  1962.     FillUIRect(left + EDGE, right - EDGE, bottom + EDGE,
  1963.         top - EDGE, UIGRAY75);
  1964.     FillUIGauzeRect(left + EDGE, right - EDGE, bottom + EDGE,
  1965.         top - EDGE, washColor);
  1966. #endif
  1967. }
  1968.  
  1969. #ifdef PROTO
  1970. void DrawRaisedRect(int left, int right, int bottom, int top, int uiColor)
  1971. #else
  1972. void DrawRaisedRect(left, right, bottom, top, uiColor)
  1973. int left; int right; int bottom; int top; int uiColor;
  1974. #endif
  1975. /* draws a raised edge with filled rectangle inside */
  1976. {
  1977. #ifdef GRAPHICS
  1978.     SetUIColor(uiColor);
  1979.     DrawInsetRect(left, right, bottom, top);
  1980.     DrawRaisedEdge(left, right, bottom, top);
  1981. #endif
  1982. }
  1983.  
  1984. #ifdef PROTO
  1985. void DrawSunkenRect(int left, int right, int bottom, int top, int uiColor)
  1986. #else
  1987. void DrawSunkenRect(left, right, bottom, top, uiColor)
  1988. int left; int right; int bottom; int top; int uiColor;
  1989. #endif
  1990. /* draws a sunken edge with filled rectangle inside */
  1991. {
  1992. #ifdef GRAPHICS
  1993.     SetUIColor(uiColor);
  1994.     DrawInsetRect(left, right, bottom, top);
  1995.     DrawSunkenEdge(left, right, bottom, top);
  1996. #endif
  1997. }
  1998.  
  1999. void SetLineWidth(width)
  2000. int width;
  2001. /*Sets the line width to width*/
  2002. {
  2003. #ifdef GRAPHICS
  2004.     if (drawingMode == DRAW_SCREEN)
  2005.     {
  2006.         linewidth(width);
  2007.     }
  2008.     else if (drawingMode == DRAW_POSTSCRIPT && psFile)
  2009.     {
  2010.         fprintf(psFile, "%d setlinewidth\n", width);
  2011.     }
  2012. #endif
  2013. }
  2014.  
  2015. void SetPointWidth(width)
  2016. int width;
  2017. /*Sets the line width to width*/
  2018. {
  2019. #ifdef GRAPHICS
  2020.     if (drawingMode == DRAW_SCREEN)
  2021.     {
  2022. #if MACHINE != RS6000
  2023.         pntsize((short) width);
  2024. #endif
  2025.     }
  2026. #endif
  2027. }
  2028.  
  2029. void    DrawMarkerSplat(left, right, bottom, top)
  2030. {
  2031.  
  2032. #ifdef GRAPHICS
  2033.  
  2034.     SetUIColor(UITEXT);
  2035.     if (drawingMode == DRAW_SCREEN)
  2036.     {
  2037.     float v[4][2];
  2038.  
  2039.     /*Draw part of button '*', the left-bottom to top-right part */
  2040.     v[0][0] = left + 2.5;
  2041.     v[0][1] = bottom + 3.5;
  2042.     v[1][0] = left + 3.5;
  2043.     v[1][1] = bottom + 2.5;
  2044.     v[2][0] = right - 2.5;
  2045.     v[2][1] = top - 3.5;
  2046.     v[3][0] = right - 3.5;
  2047.     v[3][1] = top - 2.5;
  2048.     bgnpolygon();
  2049.     v2f(v[0]);
  2050.     v2f(v[1]);
  2051.     v2f(v[2]);
  2052.     v2f(v[3]);
  2053.     endpolygon();
  2054.  
  2055.     /*Draw rest of button '*', the left-top to right-bottom part*/
  2056.     v[0][0] = left + 2.5;
  2057.     v[0][1] = top - 3.5;
  2058.     v[1][0] = left + 3.5;
  2059.     v[1][1] = top - 2.5;
  2060.     v[2][0] = right - 2.5;
  2061.     v[2][1] = bottom + 3.5;
  2062.     v[3][0] = right - 3.5;
  2063.     v[3][1] = bottom + 2.5;
  2064.     bgnpolygon();
  2065.     v2f(v[0]);
  2066.     v2f(v[1]);
  2067.     v2f(v[2]);
  2068.     v2f(v[3]);
  2069.     endpolygon();
  2070.  
  2071.     /*Draw rest of button '*', the left-to-right part*/
  2072.     v[0][0] = left + 1.5;
  2073.     v[0][1] = (top+bottom)/2.0 - 0.5;
  2074.     v[1][0] = left + 1.5;
  2075.     v[1][1] = (top+bottom)/2.0 + 0.5;
  2076.     v[2][0] = right - 1.5;
  2077.     v[2][1] = (top+bottom)/2.0 + 0.5;
  2078.     v[3][0] = right - 1.5;
  2079.     v[3][1] = (top+bottom)/2.0 - 0.5;
  2080.     bgnpolygon();
  2081.     v2f(v[0]);
  2082.     v2f(v[1]);
  2083.     v2f(v[2]);
  2084.     v2f(v[3]);
  2085.     endpolygon();
  2086.  
  2087.     /*Draw rest of button '*', the top-to-bottom part*/
  2088.     v[0][0] = (left+right)/2.0 - 0.5;
  2089.     v[0][1] = top - 1.5;
  2090.     v[1][0] = (left+right)/2.0 + 0.5;
  2091.     v[1][1] = top - 1.5;
  2092.     v[2][0] = (left+right)/2.0 + 0.5;
  2093.     v[2][1] = bottom + 1.5;
  2094.     v[3][0] = (left+right)/2.0 - 0.5;
  2095.     v[3][1] = bottom + 1.5;
  2096.     bgnpolygon();
  2097.     v2f(v[0]);
  2098.     v2f(v[1]);
  2099.     v2f(v[2]);
  2100.     v2f(v[3]);
  2101.     endpolygon();
  2102.     }
  2103.     else if (drawingMode == DRAW_POSTSCRIPT && psFile)
  2104.     {
  2105.     fprintf(psFile, "%f setgray\n", PSColor());
  2106.         fprintf(psFile,
  2107.         "%.1f %.1f moveto %.1f %.1f lineto %.1f %.1f lineto %.1f %.1f lineto closepath fill\n",
  2108.         left + 2.5, bottom + 3.5, left + 3.5, bottom + 2.5,
  2109.         right - 2.5, top - 3.5, right - 3.5, top - 2.5); 
  2110.         fprintf(psFile,
  2111.         "%.1f %.1f moveto %.1f %.1f lineto %.1f %.1f lineto %.1f %.1f lineto closepath fill\n",
  2112.         left + 2.5, top - 3.5, left + 3.5, top - 2.5,
  2113.         right - 2.5, bottom + 3.5, right - 3.5, bottom + 2.5); 
  2114.         fprintf(psFile,
  2115.         "%.1f %.1f moveto %.1f %.1f lineto %.1f %.1f lineto %.1f %.1f lineto closepath fill\n",
  2116.         left + 1.5, (top+bottom)/2.0 - 0.5, left + 1.5, (top+bottom)/2.0 + 0.5,
  2117.         right - 1.5, (top+bottom)/2.0 + 0.5, right - 1.5, (top+bottom)/2.0 - 0.5); 
  2118.         fprintf(psFile,
  2119.         "%.1f %.1f moveto %.1f %.1f lineto %.1f %.1f lineto %.1f %.1f lineto closepath fill\n",
  2120.         (left+right)/2.0 - 0.5, top - 1.5, (left+right)/2.0 + 0.5, top - 1.5,
  2121.         (left+right)/2.0 + 0.5, bottom + 1.5, (left+right)/2.0 - 0.5, bottom + 1.5); 
  2122.     }
  2123. #endif /* GRAPHICS */
  2124. }
  2125.  
  2126. void    DrawMarkerBlot(left, right, bottom, top)
  2127. int     left, right, bottom, top;
  2128. {
  2129. #ifdef GRAPHICS
  2130.     SetUIColor(UITEXT);
  2131.     FillRect(left+2.5, right-2.5, bottom+2.5, top-2.5);
  2132. #endif /*GRAPHICS*/
  2133. }
  2134.  
  2135. void    DrawMarkerCheck(left, right, bottom, top)
  2136. int    left, right, bottom, top;
  2137. {
  2138. #ifdef GRAPHICS
  2139.     float v[4][2];
  2140.  
  2141.     SetUIColor(UITEXT);
  2142.     if (drawingMode == DRAW_SCREEN)
  2143.     {
  2144.     /*Draw part of checkmark*/
  2145.     v[0][0] = left + 1.5;
  2146.     v[0][1] = (top + bottom) / 2 - 0.5;
  2147.     v[1][0] = left + 2.5;
  2148.     v[1][1] = (top + bottom) / 2 + 1.5;
  2149.     v[2][0] = left + (right - left) / 3 + 1.5;
  2150.     v[2][1] = bottom + 1.5;
  2151.     v[3][0] = left + (right - left) / 3 - 0.5;
  2152.     v[3][1] = bottom + 1.5;
  2153.     bgnpolygon();
  2154.     v2f(v[0]);
  2155.     v2f(v[1]);
  2156.     v2f(v[2]);
  2157.     v2f(v[3]);
  2158.     endpolygon();
  2159.     
  2160.     /*Draw rest of checkmark*/
  2161.     v[0][0] = left + (right - left) / 3 + 1.5;
  2162.     v[0][1] = bottom + 1.5;
  2163.     v[1][0] = left + (right - left) / 3 - 0.5;
  2164.     v[1][1] = bottom + 1.5;
  2165.     v[2][0] = right - 1.5;
  2166.     v[2][1] = top - 1.5;
  2167.     bgnpolygon();
  2168.     v2f(v[0]);
  2169.     v2f(v[1]);
  2170.     v2f(v[2]);
  2171.     endpolygon();
  2172.     }
  2173.     else if (drawingMode == DRAW_POSTSCRIPT && psFile)
  2174.     {
  2175.     fprintf(psFile, "%f setgray\n", PSColor());
  2176.     fprintf(psFile,
  2177.         "%.1f %.1f moveto %.1f %.1f lineto %.1f %.1f lineto %.1f %.1f lineto closepath fill\n",
  2178.         left + 1.5, (top + bottom) / 2 - 0.5, left + 2.5, (top + bottom) / 2 + 1.5, 
  2179.         left + (right - left) / 3 + 1.5, bottom + 1.5, left + (right - left) / 3 - 0.5, 
  2180.         bottom + 1.5);
  2181.     fprintf(psFile, "%.1f %.1f moveto %.1f %.1f lineto %.1f %.1f lineto closepath fill\n", 
  2182.         left + (right - left) / 3 + 1.5, bottom + 1.5, left + (right - left) / 3 - 0.5, 
  2183.         bottom + 1.5, right - 1.5, top - 1.5);
  2184.     }
  2185. #endif /*GRAPHICS */
  2186. }
  2187.  
  2188. void    DrawMarkerX(left, right, bottom, top)
  2189. int    left, right, bottom, top;
  2190. {
  2191. #ifdef GRAPHICS
  2192.     float v[4][2];
  2193.  
  2194.     SetUIColor(UITEXT);
  2195.     /*Draw part of button 'X'*/
  2196.     v[0][0] = left + 1.5;
  2197.     v[0][1] = bottom + 2.5;
  2198.     v[1][0] = left + 2.5;
  2199.     v[1][1] = bottom + 1.5;
  2200.     v[2][0] = right - 1.5;
  2201.     v[2][1] = top - 2.5;
  2202.     v[3][0] = right - 2.5;
  2203.     v[3][1] = top - 1.5;
  2204.     bgnpolygon();
  2205.     v2f(v[0]);
  2206.     v2f(v[1]);
  2207.     v2f(v[2]);
  2208.     v2f(v[3]);
  2209.     endpolygon();
  2210.  
  2211.     /*Draw rest of button 'X'*/
  2212.     v[0][0] = left + 1.5;
  2213.     v[0][1] = top - 2.5;
  2214.     v[1][0] = left + 2.5;
  2215.     v[1][1] = top - 1.5;
  2216.     v[2][0] = right - 1.5;
  2217.     v[2][1] = bottom + 2.5;
  2218.     v[3][0] = right - 2.5;
  2219.     v[3][1] = bottom + 1.5;
  2220.     bgnpolygon();
  2221.     v2f(v[0]);
  2222.     v2f(v[1]);
  2223.     v2f(v[2]);
  2224.     v2f(v[3]);
  2225.     endpolygon();
  2226. #endif /*GRAPHICS */
  2227. }
  2228.  
  2229. #ifdef PROTO
  2230. void DrawCtlLeft(int left, int right, int bottom, int top, int uiColor)
  2231. #else
  2232. void DrawCtlLeft(left, right, bottom, top, uiColor)
  2233. int left, right, bottom, top;
  2234. Bool highlight;
  2235. #endif
  2236. {
  2237. #ifdef GRAPHICS
  2238.     float a, b, c, d;
  2239.  
  2240.     a = left - 0.5 + 1.4142 * EDGE;
  2241.     b = left - 0.5 + 0.4142 * EDGE + (top - bottom) / 2;
  2242.     c = (top + bottom) / 2;
  2243.     d = (top - bottom) / 2;
  2244.  
  2245.     /* bottom */
  2246.     SetUIColor(UIBOTTOMEDGE);
  2247.     FillRealHex(right, bottom, left + d, bottom, left, c, a, c, b, bottom + EDGE, right - EDGE, bottom + EDGE);
  2248.  
  2249.     /* top */
  2250.     SetUIColor(UITOPEDGE);
  2251.     FillRealHex(a, c, left, c, left + d, top, right, top, right - EDGE, top - EDGE, b, top - EDGE);
  2252.  
  2253.     /* right */
  2254.     SetUIColor(UIRIGHTEDGE);
  2255.     FillRealQuad(right, top, right - EDGE, top - EDGE, right - EDGE, bottom + EDGE, right, bottom);
  2256.  
  2257.     /* surface */
  2258.     SetUIColor(uiColor);
  2259.     FillRealQuint(right - EDGE, bottom + EDGE, b, bottom + EDGE, a, c, b, top - EDGE, right - EDGE, top - EDGE);
  2260. #endif
  2261. }
  2262.  
  2263. #ifdef PROTO
  2264. void DrawCtlRight(int left, int right, int bottom, int top, int uiColor)
  2265. #else
  2266. void DrawCtlRight(left, right, bottom, top, uiColor)
  2267. int left, right, bottom, top;
  2268. Bool highlight;
  2269. #endif
  2270. {
  2271. #ifdef GRAPHICS
  2272.     float a, b, c, d;
  2273.  
  2274.     a = right + 0.5 - 1.4142 * EDGE;
  2275.     b = right + 0.5 - 0.4142 * EDGE - (top - bottom) / 2;
  2276.     c = (top + bottom) / 2;
  2277.     d = (top - bottom) / 2;
  2278.  
  2279.     /* bottom */
  2280.     SetUIColor(UIBOTTOMEDGE);
  2281.     FillRealHex(right, c, right - d, bottom, left, bottom, left + EDGE, bottom + EDGE, b, bottom + EDGE, a, c);
  2282.  
  2283.     /* top */
  2284.     SetUIColor(UITOPEDGE);
  2285.     FillRealHex(right, c, a, c, b, top - EDGE, left + EDGE, top - EDGE, left, top, right - d, top);
  2286.  
  2287.     /* left */
  2288.     SetUIColor(UILEFTEDGE);
  2289.     FillRealQuad(left, bottom, left, top, left + EDGE, top - EDGE, left + EDGE, bottom + EDGE);
  2290.  
  2291.     /* surface */
  2292.     SetUIColor(uiColor);
  2293.     FillRealQuint(a, c, b, bottom + EDGE, left + EDGE, bottom + EDGE, left + EDGE, top - EDGE, b, top - EDGE);
  2294. #endif
  2295. }
  2296.  
  2297. #ifdef PROTO
  2298. void DrawCtlUp(int left, int right, int bottom, int top, int uiColor)
  2299. #else
  2300. void DrawCtlUp(left, right, bottom, top, uiColor)
  2301. int left, right, bottom, top;
  2302. Bool highlight;
  2303. #endif
  2304. {
  2305. #ifdef GRAPHICS
  2306.     float a, b, c, d;
  2307.  
  2308.     a = top - 1.4142 * EDGE + 0.5;
  2309.     b = top - 0.4142 * EDGE - (right - left) /2;
  2310.     c = (right + left) / 2;
  2311.     d = (right - left) / 2;
  2312.  
  2313.     /* left */
  2314.     SetUIColor(UILEFTEDGE);
  2315.     FillRealHex(c, top, c, a, left + EDGE, b, left + EDGE, bottom + EDGE, left, bottom, left, top - d);
  2316.  
  2317.     /* right */
  2318.     SetUIColor(UIRIGHTEDGE);
  2319.     FillRealHex(c, top, right, top - d, right, bottom, right - EDGE, bottom + EDGE, right - EDGE, b, c, a);
  2320.  
  2321.     /* bottom */
  2322.     SetUIColor(UIBOTTOMEDGE);
  2323.     FillRealQuad(right, bottom, left, bottom, left + EDGE, bottom + EDGE, right - EDGE, bottom + EDGE);
  2324.  
  2325.     /* surface */
  2326.     SetUIColor(uiColor);
  2327.     FillRealQuint(c, a, right - EDGE, b, right - EDGE, bottom + EDGE, left + EDGE, bottom + EDGE, left + EDGE, b);
  2328. #endif
  2329. }
  2330.  
  2331. #ifdef PROTO
  2332. void DrawCtlDown(int left, int right, int bottom, int top, int uiColor)
  2333. #else
  2334. void DrawCtlDown(left, right, bottom, top, uiColor)
  2335. int left, right, bottom, top;
  2336. Bool highlight;
  2337. #endif
  2338. {
  2339. #ifdef GRAPHICS
  2340.     float a, b, c, d;
  2341.  
  2342.     a = bottom + 1.4142 * EDGE - 0.5;
  2343.     b = bottom + 0.4142 * EDGE - (right - left) /2;
  2344.     c = (right + left) / 2;
  2345.     d = (right - left) / 2;
  2346.  
  2347.     /* left */
  2348.     SetUIColor(UILEFTEDGE);
  2349.     FillRealHex(c, bottom, left, bottom + d, left, top, left + EDGE, top - EDGE, left + EDGE, b, c, a);
  2350.  
  2351.     /* right */
  2352.     SetUIColor(UIRIGHTEDGE);
  2353.     FillRealHex(c, bottom, c, a, right - EDGE, b, right - EDGE, top - EDGE, right, top, right, bottom + d);
  2354.  
  2355.     /* top */
  2356.     SetUIColor(UITOPEDGE);
  2357.     FillRealQuad(right, top, right - EDGE, top - EDGE, left + EDGE, top - EDGE, left, top);
  2358.  
  2359.     /* surface */
  2360.     SetUIColor(uiColor);
  2361.     FillRealQuint(c, a, left + EDGE, b, left + EDGE, top - EDGE, right - EDGE, top - EDGE, right - EDGE, b);
  2362. #endif
  2363. }
  2364.  
  2365. #ifdef PROTO
  2366. void SavePSImage(FILE *psFile, Pixel *imageBuffer, int left, int right, int bottom, int top)
  2367. #else
  2368. void SavePSImage(psFile, imageBuffer, left, right, bottom, top)
  2369. FILE *psFile;
  2370. Pixel *imageBuffer;
  2371. int left;
  2372. int right;
  2373. int bottom;
  2374. int top;
  2375. #endif
  2376. /*Saves an image in imageBuffer within left, right, bottom, top into psFile*/
  2377. {
  2378.     real y, dummy;
  2379.     int iVal;
  2380.     long k;
  2381.     int pixWrap;
  2382.     long nPixels;
  2383.     long i, j, ip, jp;
  2384.     long width, height;
  2385.     int subSample;
  2386.  
  2387.     subSample = imageSubSample + 1;
  2388.  
  2389.  
  2390.     width = right - left;
  2391.     height = top - bottom;
  2392.  
  2393. #define PIXPERLINE    10
  2394.  
  2395. #ifdef COLORPOST
  2396.     /*Color image.  Do stuff before pixels*/
  2397.     fprintf(psFile, "%% Color Space image within %d %d %d %d\n",
  2398.         left, right, bottom, top);
  2399.     fprintf(psFile, "%d %d moveto\n", left, bottom);
  2400.     fprintf(psFile, "/imgstr %d string def\n", 3 * width);
  2401.     fprintf(psFile, "%d %d %d matrix \n", right - left, top - bottom, 8);
  2402.  
  2403.     /*Do pixels*/
  2404.     nPixels = width * height;
  2405.     pixWrap = 0;
  2406.     fprintf(psFile, "{currentfile imgstr readhexstring pop} false 3 colorimage\n");
  2407.     for (k = 0; k < nPixels; ++k)
  2408.     {
  2409.     fprintf(psFile, "%02X%02X%02X%s",
  2410.         LinToGamma[imageBuffer[k] . red],
  2411.         LinToGamma[imageBuffer[k] . green],
  2412.         LinToGamma[imageBuffer[k] . blue],
  2413.         (++pixWrap) % PIXPERLINE ? " " : "\n");
  2414.     }
  2415.     fprintf(psFile, "\n\n");
  2416. #else
  2417.     /*B/W image.  Do stuff before pixels*/
  2418.     fprintf(psFile, "%% B/W Space image within %d %d %d %d\n",
  2419.         left, right, bottom, top);
  2420.     fprintf(psFile, "/imgstr %d string def\n", width / subSample);
  2421.     fprintf(psFile, "%d %d %d\n", width / subSample, height / subSample, 8);
  2422.     fprintf(psFile, "%d %d matrix translate\n",
  2423.         -left, -bottom);
  2424.     fprintf(psFile, "%lg %lg matrix scale\n",
  2425.         1.0 / (double) subSample, 1.0 / (double) subSample);
  2426.     fprintf(psFile, " matrix concatmatrix\n");
  2427.  
  2428.     /*Do pixels*/
  2429.     nPixels = (right - left) * (top - bottom);
  2430.     pixWrap = 0;
  2431.     fprintf(psFile, "{currentfile imgstr readhexstring pop} image\n");
  2432.  
  2433.  
  2434.     for (j = 0; j < height; j += subSample)
  2435.     {
  2436.     for (i = 0; i < width; i += subSample)
  2437.     {
  2438.         real avgPixel;
  2439.  
  2440.         avgPixel = 0.0;
  2441.  
  2442.         /*Calculate an average pixel*/
  2443.         for (jp = j; jp < j + subSample; ++jp)
  2444.         {
  2445.         for (ip = i; ip < i + subSample; ++ip)
  2446.         {
  2447.             k = ip + jp * width;
  2448.  
  2449.             RGB2YIQ(&y, &dummy, &dummy,
  2450.             imageBuffer[k] . red / 255.0,
  2451.             imageBuffer[k] . green / 255.0,
  2452.             imageBuffer[k] . blue / 255.0);
  2453.  
  2454.             avgPixel += y;
  2455.         }
  2456.         }
  2457.         avgPixel /= (real) subSample;
  2458.         avgPixel /= (real) subSample;
  2459.  
  2460.         iVal = avgPixel * 255.0;
  2461.         if (iVal < 0) iVal = 0;
  2462.         if (iVal > 255) iVal = 255;
  2463.         fprintf(psFile, "%02X%s", LinToGamma[iVal],
  2464.         (++pixWrap) % PIXPERLINE ? " " : "\n");
  2465.     }
  2466.     }
  2467.  
  2468.     fprintf(psFile, "\n\n");
  2469.  
  2470. #endif
  2471.  
  2472. #undef PIXPERLINE
  2473.  
  2474. }
  2475.  
  2476. /*
  2477.  * Icons in eps files 10/28/92
  2478.  * In order to make the eps file of a window self contained, a bit-mapped
  2479.  * font of just the icons used in that window is defined in the file. In PS
  2480.  * drawing mode, RegisterIconUsed keeps a list of the icon numbers used.
  2481.  * It returns the index of the icon in the list. EndDrawing uses the list
  2482.  * to create the font definition. If there are any icons in the window, the
  2483.  * file must be rewritten with the font definition in the header. The font
  2484.  * definition is generated by GenIconDef() in ScianIcons.c.
  2485.  */
  2486.  
  2487. #ifdef PROTO
  2488. void DrawPSFrame(char *name, int left, int right, int bottom, int top)
  2489. #else
  2490. void DrawPSFrame(name, left, right, bottom, top)
  2491. char *name;
  2492. int left;
  2493. int right;
  2494. int bottom;
  2495. int top;
  2496. #endif
  2497. /*Draws a PostScript frame around left, right, bottom, top*/
  2498. {
  2499.     left -= WINFRAMEWID;
  2500.     right -= WINFRAMEWID;
  2501.     bottom -= WINFRAMEWID;
  2502.     top -= WINFRAMEWID;
  2503.     {
  2504.         /* draw a generic window frame with title only */
  2505.         fprintf(psFile,
  2506. "newpath 0 0 moveto 0 %d lineto %d %d lineto %d 0 lineto closepath stroke\n", 
  2507.         top, right, top, right);
  2508.         fprintf(psFile, 
  2509. "newpath %d %d moveto %d %d lineto %d %d lineto %d %d lineto closepath stroke\n", 
  2510.         WINFRAMEWID - 1, WINFRAMEWID - 1,
  2511.         WINFRAMEWID - 1, top - WINFRAMEWID + 1,
  2512.         right - WINFRAMEWID + 1, top - WINFRAMEWID + 1,
  2513.         right - WINFRAMEWID + 1, WINFRAMEWID - 1);
  2514.         fprintf(psFile, "newpath %d %d moveto %d %d lineto stroke\n", 
  2515.         WINFRAMEWID - 1, top - WINFRAMEWID - WINTITLEHT + 1, 
  2516.         right - WINFRAMEWID + 1, top - WINFRAMEWID - WINTITLEHT + 1);
  2517.         SetupFont(WINTITLEFONT, 12);
  2518.         fprintf(psFile, "%d %d moveto (%s) show\n", 
  2519.         WINFRAMEWID + 20, top - WINFRAMEWID - WINTITLEHT + 5, show(name));
  2520.         RegisterFontUsed(WINTITLEFONT);
  2521.     }
  2522. }
  2523.  
  2524. #ifdef PROTO
  2525. void BeginDrawSubscreen(int ox, int oy)
  2526. #else
  2527. void BeginDrawSubscreen(ox, oy)
  2528. int ox, oy;
  2529. #endif
  2530. /*Begins a drawing segment offset by ox, oy*/
  2531. {
  2532.     if (drawingMode == DRAW_POSTSCRIPT && psFile)
  2533.     {
  2534.     fprintf(psFile, "%d %d translate\n", ox, oy);
  2535.     }
  2536. }
  2537.  
  2538. #ifdef PROTO
  2539. void EndDrawSubscreen(int ox, int oy)
  2540. #else
  2541. void EndDrawSubscreen(ox, oy)
  2542. int ox, oy;
  2543. #endif
  2544. /*Begins a drawing segment offset by ox, oy*/
  2545. {
  2546.     if (drawingMode == DRAW_POSTSCRIPT && psFile)
  2547.     {
  2548.     fprintf(psFile, "%d %d translate\n", -ox,  -oy);
  2549.     }
  2550. }
  2551.  
  2552. #ifdef PROTO
  2553. void BeginDrawing(char *name, int left, int right, int bottom, int top, real scale)
  2554. #else
  2555. void BeginDrawing(name, left, right, bottom, top, scale)
  2556. char *name;            /*Window title*/
  2557. int left, right, bottom, top;    /*Coordinates of window INTERIOR*/
  2558. real scale;
  2559. #endif
  2560. {
  2561. #ifdef GRAPHICS
  2562.     psFile = tmpfile();
  2563.     if (drawingMode == DRAW_POSTSCRIPT && psFile)
  2564.     {
  2565.     struct timeval date;
  2566.  
  2567.         gettimeofday(&date, (struct timezone *)0);
  2568.     
  2569.     /* "normalize" bounds */
  2570.     right -= left;
  2571.     top -= bottom;
  2572.  
  2573.     /* initialize counters */
  2574.     numFontsUsed = 0;
  2575.     numIconsUsed = 0;
  2576.  
  2577.         /* write EPS header */
  2578.         fprintf(psFile,
  2579. "\
  2580. %%!PS-Adobe-2.0 EPSF-2.0\n\
  2581. %%%%Title: %s\n\
  2582. %%%%Creator: SciAn\n\
  2583. %%%%CreationDate: %s\
  2584. %%%%For: %s\n\
  2585. %%%%DocumentFonts: (atend)\n\
  2586. %%%%BoundingBox: 0 0 %d %d\n\
  2587. %%%%EndComments\n\
  2588. save\n\n",    /* NOTE: icon font def is inserted after first blank line of file */
  2589.         name, ctime(&date.tv_sec), getenv("USER"),
  2590.         (int) (scale * (real) (right + 1)), (int) (scale * (real) (top + 1)));
  2591.     
  2592.     fprintf(psFile, 
  2593. "/resetclip {matrix currentmatrix currentfont currentlinewidth\n\
  2594. grestore gsave setlinewidth setfont setmatrix } def\n\
  2595. \n\
  2596. currentscreen 3 1 roll pop pop 75 0 3 -1 roll setscreen\n\
  2597. gsave\n\
  2598. 1 setlinewidth\n\
  2599. %g %g scale\n\n\n", scale, scale);
  2600.  
  2601.     }
  2602. #endif
  2603. }
  2604.  
  2605. #ifdef PROTO
  2606. void EndDrawing(Bool showpagep)
  2607. #else
  2608. void EndDrawing(showpagep)
  2609. Bool showpagep;
  2610. #endif
  2611. {
  2612. #ifdef GRAPHICS
  2613.     if (drawingMode == DRAW_POSTSCRIPT && psFile && drawFile)
  2614.     {
  2615.     char buf[256];
  2616.         int i;
  2617.     
  2618.     /* copy header from temp file (copies to first blank line) */
  2619.     rewind(psFile);
  2620.     while (fgets(buf, 256, psFile))
  2621.     {
  2622.         fputs(buf, drawFile);
  2623.         if (*buf == '\n') break;
  2624.     }
  2625.     
  2626.     /* generate font of icons used, if needed */
  2627.     GenIconDef(drawFile);
  2628.     
  2629.     /* copy the rest of the temp file */
  2630.     while (fgets(buf, 256, psFile))
  2631.     {
  2632.         fputs(buf, drawFile);
  2633.     }
  2634.     fclose(psFile);
  2635.  
  2636.     if (showpagep)
  2637.     {
  2638.         fprintf(drawFile, "\nshowpage\n");
  2639.     }
  2640.  
  2641.         /* write PostScript trailer -- list fonts used */
  2642.         fprintf(drawFile, "\nrestore\n\n%%%%Trailer\n%%%%DocumentFonts:");
  2643.     for (i=0; i<numFontsUsed; ++i)
  2644.         {
  2645.             fprintf(drawFile, " %s", fontsUsed[i]);
  2646.  
  2647.         /* free the fontsUsed string space */
  2648.             Free(fontsUsed[i]);
  2649.             fontsUsed[i] = NIL;
  2650.         }
  2651.         fprintf(drawFile, "\n");
  2652.     }
  2653. #endif
  2654. }
  2655.  
  2656. #ifdef PROTO
  2657. int RegisterIconUsed(int icon)
  2658. #else
  2659. int RegisterIconUsed(icon)
  2660. int icon;
  2661. #endif
  2662. {
  2663. #ifdef GRAPHICS
  2664.     int i;
  2665.  
  2666.     /* check list of icons used */
  2667.     for (i = 0; i < numIconsUsed; ++i)
  2668.     {
  2669.         if (icon == iconsUsed[i]) return i; /* already got it */
  2670.     }
  2671.     if (numIconsUsed >= 32)
  2672.     {
  2673.         ReportError("RegisterIconUsed","Too many different icons!");
  2674.         return -1;
  2675.     }
  2676.     iconsUsed[numIconsUsed] = icon;
  2677.     return numIconsUsed++;
  2678. #else
  2679.     return 0;
  2680. #endif
  2681. }
  2682.  
  2683. void EraseAll()
  2684. /*Erases everything*/
  2685. {
  2686.     SetUIColor(UIBLACK);
  2687.     clear();
  2688. }
  2689.  
  2690. void InitDraw()
  2691. /*Initializes the drawing system*/
  2692. {
  2693.     int k;
  2694.  
  2695.     /*No window at the beginning*/
  2696.     curDrawingStateIndex = 0;
  2697.     CURSTATE . window = 0;
  2698.     CURSTATE . initialWindow = false;
  2699.     for (k = 0; k < 4; ++k)
  2700.     {
  2701.     CURSTATE . screenMask[k] = 0;
  2702.     CURSTATE . viewport[k] = 0;
  2703.     }
  2704.     for (k = 0; k < 2; ++k)
  2705.     {
  2706.     CURSTATE . origin[k] = 0;
  2707.     CURSTATE . translation[k] = 0;
  2708.     }
  2709. }
  2710.  
  2711. void KillDraw()
  2712. {
  2713. }
  2714.